@jagilber-org/index-server 1.28.2 → 1.28.5

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);
+}

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

@@ -0,0 +1,18 @@
+export type McpClientTarget = 'vscode' | 'copilot-cli' | 'claude';
+export type McpConfigFormat = 'vscode' | 'vscode-global' | 'copilot-cli' | 'claude';
+export type McpScope = 'repo' | 'global';
+export interface ResolveTargetOptions {
+    targets?: McpClientTarget[];
+    target?: McpClientTarget;
+    scope?: McpScope;
+    root?: string;
+    home?: string;
+    appData?: string;
+}
+export interface McpTargetInfo {
+    target: McpClientTarget;
+    format: McpConfigFormat;
+    path: string;
+}
+export declare function defaultConfigRoot(): string;
+export declare function resolveConfigTargets(options?: ResolveTargetOptions): McpTargetInfo[];

package/dist/services/mcpConfig/paths.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConfigRoot = defaultConfigRoot;
+exports.resolveConfigTargets = resolveConfigTargets;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function envValue(key) {
+    const value = process.env[key];
+    return value && value.length > 0 ? value : undefined;
+}
+function defaultConfigRoot() {
+    return path_1.default.resolve(envValue('INDEX_SERVER_MCP_CONFIG_ROOT') ?? process.cwd());
+}
+function resolveConfigTargets(options = {}) {
+    const pathApi = process.platform === 'win32' ? path_1.default.win32 : path_1.default.posix;
+    const root = pathApi.resolve(options.root ?? defaultConfigRoot());
+    const scope = options.scope ?? 'repo';
+    const home = options.home ?? os_1.default.homedir();
+    const appData = options.appData ?? envValue('APPDATA') ?? pathApi.join(home, 'AppData', 'Roaming');
+    const targets = options.targets ?? (options.target ? [options.target] : ['vscode']);
+    const isWin = process.platform === 'win32';
+    const isMac = process.platform === 'darwin';
+    const results = [];
+    for (const target of targets) {
+        if (target === 'vscode') {
+            if (scope === 'global') {
+                const dir = isWin ? pathApi.join(appData, 'Code', 'User') : pathApi.join(home, '.config', 'Code', 'User');
+                results.push({ target, format: 'vscode-global', path: pathApi.join(dir, 'mcp.json') });
+            }
+            else {
+                results.push({ target, format: 'vscode', path: pathApi.join(root, '.vscode', 'mcp.json') });
+            }
+        }
+        else if (target === 'copilot-cli') {
+            results.push({ target, format: 'copilot-cli', path: pathApi.join(home, '.copilot', 'mcp-config.json') });
+        }
+        else if (target === 'claude') {
+            const dir = isWin
+                ? pathApi.join(appData, 'Claude')
+                : isMac
+                    ? pathApi.join(home, 'Library', 'Application Support', 'Claude')
+                    : pathApi.join(home, '.config', 'Claude');
+            results.push({ target, format: 'claude', path: pathApi.join(dir, 'claude_desktop_config.json') });
+        }
+    }
+    return results;
+}

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

@@ -0,0 +1,7 @@
+import type { McpConfigFormat } from './paths';
+export interface ValidationResult {
+    ok: boolean;
+    errors: string[];
+}
+export declare function validateConfigObject(format: McpConfigFormat, config: Record<string, unknown>): ValidationResult;
+export declare function assertValidConfigObject(format: McpConfigFormat, config: Record<string, unknown>, phase: string): void;

package/dist/services/mcpConfig/validate.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfigObject = validateConfigObject;
+exports.assertValidConfigObject = assertValidConfigObject;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ajv_1 = __importDefault(require("ajv"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const flagCatalog_1 = require("./flagCatalog");
+const formats_1 = require("./formats");
+function schemaRoot() {
+    return path_1.default.resolve(__dirname, '..', '..', '..', 'schemas');
+}
+function schemaPathForFormat(format) {
+    if (format === 'vscode' || format === 'vscode-global')
+        return path_1.default.join(schemaRoot(), 'mcp.vscode.schema.json');
+    if (format === 'copilot-cli')
+        return path_1.default.join(schemaRoot(), 'mcp.copilot-cli.schema.json');
+    return path_1.default.join(schemaRoot(), 'mcp.claude.schema.json');
+}
+function loadJson(filePath) {
+    return JSON.parse(fs_1.default.readFileSync(filePath, 'utf8'));
+}
+function createAjv() {
+    const ajv = new ajv_1.default({ allErrors: true, strict: false });
+    (0, ajv_formats_1.default)(ajv);
+    ajv.addSchema(loadJson(path_1.default.join(schemaRoot(), 'mcp.indexServerEnv.schema.json')), 'mcp.indexServerEnv.schema.json');
+    return ajv;
+}
+function collectAjvErrors(validate) {
+    return (validate.errors ?? []).map((error) => `${error.instancePath || '/'} ${error.message ?? 'failed validation'}`);
+}
+function validateConfigObject(format, config) {
+    const ajv = createAjv();
+    const schema = loadJson(schemaPathForFormat(format));
+    const validate = ajv.compile(schema);
+    const valid = validate(config);
+    const errors = valid ? [] : collectAjvErrors(validate);
+    try {
+        for (const entry of Object.values((0, formats_1.getServerMap)(config, format))) {
+            if (!entry.env)
+                continue;
+            for (const key of Object.keys(entry.env)) {
+                if (key.startsWith('INDEX_SERVER_') && !flagCatalog_1.DOCUMENTED_INDEX_SERVER_FLAGS.includes(key)) {
+                    errors.push(`env contains unsupported INDEX_SERVER key: ${key}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+    }
+    return { ok: errors.length === 0, errors };
+}
+function assertValidConfigObject(format, config, phase) {
+    const result = validateConfigObject(format, config);
+    if (!result.ok)
+        throw new Error(`MCP config validation failed during ${phase}: ${result.errors.join('; ')}`);
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@jagilber-org/index-server",
-  "version": "1.28.2",
+  "version": "1.28.5",
   "mcpName": "io.github.jagilber-org/index-server",
   "description": "MCP instruction indexing server with search, CRUD, validation, and cross-repo knowledge promotion.",
   "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
+    "registry": "https://npm.pkg.github.com",
     "access": "public"
   },
   "type": "commonjs",
@@ -134,6 +134,7 @@
     "ajv-formats": "^2.1.1",
     "express": "^5.2.1",
     "express-rate-limit": "^8.3.2",
+    "jsonc-parser": "^3.3.1",
     "safe-regex2": "^5.1.1",
     "sqlite-vec": "0.1.9",
     "ws": "^8.19.0",

package/schemas/mcp.claude.schema.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "mcp.claude.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["mcpServers"],
+  "properties": {
+    "mcpServers": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["command", "args"],
+        "properties": {
+          "type": { "type": "string" },
+          "command": { "type": "string", "minLength": 1 },
+          "args": { "type": "array", "items": { "type": "string" }, "minItems": 1 },
+          "cwd": { "type": "string" },
+          "env": {
+            "type": "object",
+            "additionalProperties": { "type": "string" }
+          }
+        }
+      }
+    }
+  }
+}

package/schemas/mcp.copilot-cli.schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "mcp.copilot-cli.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["mcpServers"],
+  "properties": {
+    "mcpServers": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["command", "args"],
+        "properties": {
+          "type": { "type": "string" },
+          "command": { "type": "string", "minLength": 1 },
+          "args": { "type": "array", "items": { "type": "string" }, "minItems": 1 },
+          "cwd": { "type": "string" },
+          "tools": { "type": "array", "items": { "type": "string" } },
+          "env": {
+            "type": "object",
+            "additionalProperties": { "type": "string" }
+          }
+        }
+      }
+    }
+  }
+}

package/schemas/mcp.indexServerEnv.schema.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "mcp.indexServerEnv.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "patternProperties": {
+    "^INDEX_SERVER_[A-Z0-9_]+$": { "type": "string" }
+  }
+}

package/schemas/mcp.vscode.schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "mcp.vscode.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["servers"],
+  "properties": {
+    "servers": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["type", "command", "args"],
+        "properties": {
+          "type": { "const": "stdio" },
+          "command": { "type": "string", "minLength": 1 },
+          "args": { "type": "array", "items": { "type": "string" }, "minItems": 1 },
+          "cwd": { "type": "string" },
+          "env": {
+            "type": "object",
+            "additionalProperties": { "type": "string" }
+          }
+        }
+      }
+    },
+    "inputs": { "type": "array" }
+  }
+}