@gleanwork/mcp-config 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025, Glean Technologies Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# @gleanwork/mcp-config
+
+Glean-specific MCP configuration defaults and helpers. Wraps `@gleanwork/mcp-config-schema` with Glean-specific constants and convenience functions.
+
+## Installation
+
+```bash
+npm install @gleanwork/mcp-config
+```
+
+## Usage
+
+### Quick Start
+
+```typescript
+import {
+  createGleanRegistry,
+  createGleanEnv,
+  createGleanHeaders,
+  buildGleanServerUrl,
+} from '@gleanwork/mcp-config';
+
+// Create a pre-configured registry
+const registry = createGleanRegistry();
+const builder = registry.createBuilder('cursor');
+
+// Generate stdio configuration
+const stdioConfig = builder.buildConfiguration({
+  transport: 'stdio',
+  env: createGleanEnv('my-company', 'my-api-token'),
+});
+
+// Generate HTTP configuration
+const httpConfig = builder.buildConfiguration({
+  transport: 'http',
+  serverUrl: buildGleanServerUrl('my-company'),
+  headers: createGleanHeaders('my-api-token'),
+});
+```
+
+### Available Exports
+
+#### Constants
+
+```typescript
+import { GLEAN_REGISTRY_OPTIONS, GLEAN_ENV } from '@gleanwork/mcp-config';
+
+// Registry options for Glean MCP server
+GLEAN_REGISTRY_OPTIONS.serverPackage    // '@gleanwork/local-mcp-server'
+GLEAN_REGISTRY_OPTIONS.commandBuilder   // Functions to generate CLI commands
+GLEAN_REGISTRY_OPTIONS.serverNameBuilder // Callback that prefixes server names with glean_
+
+// Environment variable names
+GLEAN_ENV.INSTANCE   // 'GLEAN_INSTANCE'
+GLEAN_ENV.URL        // 'GLEAN_URL'
+GLEAN_ENV.API_TOKEN  // 'GLEAN_API_TOKEN'
+```
+
+#### Helper Functions
+
+| Function | Description |
+|----------|-------------|
+| `createGleanRegistry()` | Create MCPConfigRegistry with Glean defaults |
+| `createGleanEnv(instance, apiToken?)` | Create env vars using instance name |
+| `createGleanUrlEnv(url, apiToken?)` | Create env vars using full URL |
+| `createGleanHeaders(apiToken)` | Create Authorization header |
+| `buildGleanServerUrl(instance, endpoint?)` | Build Glean MCP server URL |
+| `normalizeGleanProductName(productName?)` | Normalize product name for white-labeling (defaults to 'glean') |
+| `buildGleanServerName(options)` | Build server name with glean_ prefix |
+| `normalizeGleanServerName(name, productName?)` | Normalize server name to safe config key with prefix |
+
+#### Server Name Functions
+
+These functions handle server name generation with proper prefixing:
+
+```typescript
+import {
+  normalizeGleanProductName,
+  buildGleanServerName,
+  normalizeGleanServerName,
+} from '@gleanwork/mcp-config';
+
+// Normalize product names for white-labeling
+normalizeGleanProductName();              // 'glean'
+normalizeGleanProductName('Acme Corp');   // 'acme_corp'
+
+// Build server names with glean_ prefix
+buildGleanServerName({ transport: 'stdio' });                              // 'glean_local'
+buildGleanServerName({ transport: 'http' });                               // 'glean_default'
+buildGleanServerName({ transport: 'http', serverUrl: '.../mcp/analytics' }); // 'glean_analytics'
+buildGleanServerName({ serverName: 'custom' });                            // 'glean_custom'
+buildGleanServerName({ agents: true });                                    // 'glean_agents'
+
+// Normalize existing server names
+normalizeGleanServerName('custom');        // 'glean_custom'
+normalizeGleanServerName('glean_custom');  // 'glean_custom' (no double prefix)
+```
+
+#### Types
+
+```typescript
+import type { GleanConnectionOptions, GleanEnvVars } from '@gleanwork/mcp-config';
+
+// GleanConnectionOptions extends MCPConnectionOptions with:
+// - productName?: string  (for white-label support)
+// - agents?: boolean      (use agents endpoint)
+```
+
+### Re-exports
+
+This package re-exports everything from `@gleanwork/mcp-config-schema`, so you can import both Glean-specific and generic types from a single package:
+
+```typescript
+import {
+  // Glean-specific
+  createGleanRegistry,
+  createGleanEnv,
+  GLEAN_ENV,
+
+  // From mcp-config-schema
+  MCPConfigRegistry,
+  type MCPConnectionOptions,
+  type ClientId,
+} from '@gleanwork/mcp-config';
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,141 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  GLEAN_ENV: () => GLEAN_ENV,
+  GLEAN_REGISTRY_OPTIONS: () => GLEAN_REGISTRY_OPTIONS,
+  buildGleanServerName: () => buildGleanServerName,
+  buildGleanServerUrl: () => buildGleanServerUrl,
+  createGleanEnv: () => createGleanEnv,
+  createGleanHeaders: () => createGleanHeaders,
+  createGleanRegistry: () => createGleanRegistry,
+  createGleanUrlEnv: () => createGleanUrlEnv,
+  normalizeGleanProductName: () => normalizeGleanProductName,
+  normalizeGleanServerName: () => normalizeGleanServerName
+});
+module.exports = __toCommonJS(index_exports);
+var import_mcp_config_schema = require("@gleanwork/mcp-config-schema");
+__reExport(index_exports, require("@gleanwork/mcp-config-schema"), module.exports);
+var GLEAN_REGISTRY_OPTIONS = {
+  serverPackage: "@gleanwork/local-mcp-server",
+  commandBuilder: {
+    http: (clientId, options) => {
+      if (!options.serverUrl) return null;
+      return `npx -y @gleanwork/configure-mcp-server remote --url ${options.serverUrl} --client ${clientId}`;
+    },
+    stdio: (clientId, options) => {
+      const envFlags = Object.entries(options.env || {}).map(([k, v]) => `--env ${k}=${v}`).join(" ");
+      return `npx -y @gleanwork/configure-mcp-server local --client ${clientId}${envFlags ? ` ${envFlags}` : ""}`;
+    }
+  },
+  serverNameBuilder: (options) => {
+    return buildGleanServerName(options);
+  }
+};
+var GLEAN_ENV = {
+  /** Environment variable for Glean instance name (e.g., 'my-company') */
+  INSTANCE: "GLEAN_INSTANCE",
+  /** Environment variable for full Glean URL (e.g., 'https://my-company.glean.com') */
+  URL: "GLEAN_URL",
+  /** Environment variable for Glean API token */
+  API_TOKEN: "GLEAN_API_TOKEN"
+};
+function createGleanEnv(instance, apiToken) {
+  return {
+    [GLEAN_ENV.INSTANCE]: instance,
+    ...apiToken && { [GLEAN_ENV.API_TOKEN]: apiToken }
+  };
+}
+function createGleanUrlEnv(url, apiToken) {
+  return {
+    [GLEAN_ENV.URL]: url,
+    ...apiToken && { [GLEAN_ENV.API_TOKEN]: apiToken }
+  };
+}
+function createGleanHeaders(apiToken) {
+  return {
+    Authorization: `Bearer ${apiToken}`
+  };
+}
+function createGleanRegistry() {
+  return new import_mcp_config_schema.MCPConfigRegistry(GLEAN_REGISTRY_OPTIONS);
+}
+function buildGleanServerUrl(instance, endpoint = "default") {
+  return `https://${instance}-be.glean.com/mcp/${endpoint}`;
+}
+function normalizeGleanProductName(productName) {
+  if (!productName) {
+    return "glean";
+  }
+  const normalized = productName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  return normalized || "glean";
+}
+function buildGleanServerName(options) {
+  const productPrefix = normalizeGleanProductName(options.productName);
+  if (options.serverName) {
+    if (options.serverName === productPrefix || options.serverName.startsWith(`${productPrefix}_`)) {
+      return options.serverName;
+    }
+    return `${productPrefix}_${options.serverName}`;
+  }
+  if (options.agents) {
+    return `${productPrefix}_agents`;
+  }
+  const baseName = (0, import_mcp_config_schema.buildMcpServerName)({
+    transport: options.transport,
+    serverUrl: options.serverUrl
+  });
+  if (baseName === "default" && !options.transport && !options.serverUrl) {
+    return productPrefix;
+  }
+  return `${productPrefix}_${baseName}`;
+}
+function normalizeGleanServerName(name, productName) {
+  const productPrefix = normalizeGleanProductName(productName);
+  if (!name) {
+    return productPrefix;
+  }
+  const lowerName = name.toLowerCase();
+  if (lowerName === productPrefix || lowerName.startsWith(`${productPrefix}_`)) {
+    return lowerName;
+  }
+  if (lowerName.startsWith(productPrefix) && lowerName.length > productPrefix.length) {
+    const rest = lowerName.slice(productPrefix.length);
+    return `${productPrefix}_${rest}`;
+  }
+  return `${productPrefix}_${lowerName}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GLEAN_ENV,
+  GLEAN_REGISTRY_OPTIONS,
+  buildGleanServerName,
+  buildGleanServerUrl,
+  createGleanEnv,
+  createGleanHeaders,
+  createGleanRegistry,
+  createGleanUrlEnv,
+  normalizeGleanProductName,
+  normalizeGleanServerName,
+  ...require("@gleanwork/mcp-config-schema")
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {\n  MCPConfigRegistry,\n  buildMcpServerName as buildMcpServerNameBase,\n  type MCPConnectionOptions,\n  type RegistryOptions,\n} from '@gleanwork/mcp-config-schema';\n\n// Re-export everything from the base package for convenience\nexport * from '@gleanwork/mcp-config-schema';\n\n/**\n * Glean-specific registry options for stdio transport.\n */\nexport const GLEAN_REGISTRY_OPTIONS: RegistryOptions = {\n  serverPackage: '@gleanwork/local-mcp-server',\n  commandBuilder: {\n    http: (clientId, options) => {\n      if (!options.serverUrl) return null;\n      return `npx -y @gleanwork/configure-mcp-server remote --url ${options.serverUrl} --client ${clientId}`;\n    },\n    stdio: (clientId, options) => {\n      const envFlags = Object.entries(options.env || {})\n        .map(([k, v]) => `--env ${k}=${v}`)\n        .join(' ');\n      return `npx -y @gleanwork/configure-mcp-server local --client ${clientId}${envFlags ? ` ${envFlags}` : ''}`;\n    },\n  },\n  serverNameBuilder: (options) => {\n    // Lazily call buildGleanServerName defined below\n    return buildGleanServerName(options);\n  },\n};\n\n/**\n * Glean environment variable names.\n */\nexport const GLEAN_ENV = {\n  /** Environment variable for Glean instance name (e.g., 'my-company') */\n  INSTANCE: 'GLEAN_INSTANCE',\n  /** Environment variable for full Glean URL (e.g., 'https://my-company.glean.com') */\n  URL: 'GLEAN_URL',\n  /** Environment variable for Glean API token */\n  API_TOKEN: 'GLEAN_API_TOKEN',\n} as const;\n\n/**\n * Helper to create Glean environment variables for stdio transport.\n *\n * @param instance - Glean instance name (e.g., 'my-company')\n * @param apiToken - Optional API token\n * @returns Environment variables object for use in MCPConnectionOptions.env\n *\n * @example\n * ```typescript\n * const config = builder.buildConfiguration({\n *   transport: 'stdio',\n *   env: createGleanEnv('my-company', 'my-api-token'),\n * });\n * ```\n */\nexport function createGleanEnv(instance: string, apiToken?: string): Record<string, string> {\n  return {\n    [GLEAN_ENV.INSTANCE]: instance,\n    ...(apiToken && { [GLEAN_ENV.API_TOKEN]: apiToken }),\n  };\n}\n\n/**\n * Helper to create Glean environment variables using a full URL.\n *\n * @param url - Full Glean URL (e.g., 'https://my-company.glean.com')\n * @param apiToken - Optional API token\n * @returns Environment variables object for use in MCPConnectionOptions.env\n *\n * @example\n * ```typescript\n * const config = builder.buildConfiguration({\n *   transport: 'stdio',\n *   env: createGleanUrlEnv('https://my-company.glean.com', 'my-api-token'),\n * });\n * ```\n */\nexport function createGleanUrlEnv(url: string, apiToken?: string): Record<string, string> {\n  return {\n    [GLEAN_ENV.URL]: url,\n    ...(apiToken && { [GLEAN_ENV.API_TOKEN]: apiToken }),\n  };\n}\n\n/**\n * Helper to create Glean authorization headers for HTTP transport.\n *\n * @param apiToken - Glean API token\n * @returns Headers object for use in MCPConnectionOptions.headers\n *\n * @example\n * ```typescript\n * const config = builder.buildConfiguration({\n *   transport: 'http',\n *   serverUrl: 'https://my-company-be.glean.com/mcp/default',\n *   headers: createGleanHeaders('my-api-token'),\n * });\n * ```\n */\nexport function createGleanHeaders(apiToken: string): Record<string, string> {\n  return {\n    Authorization: `Bearer ${apiToken}`,\n  };\n}\n\n/**\n * Create an MCPConfigRegistry pre-configured with Glean defaults.\n *\n * @returns MCPConfigRegistry configured for Glean stdio transport\n *\n * @example\n * ```typescript\n * const registry = createGleanRegistry();\n * const builder = registry.createBuilder('cursor');\n *\n * // For stdio transport\n * const config = builder.buildConfiguration({\n *   transport: 'stdio',\n *   env: createGleanEnv('my-company', 'my-api-token'),\n * });\n *\n * // For HTTP transport\n * const httpConfig = builder.buildConfiguration({\n *   transport: 'http',\n *   serverUrl: 'https://my-company-be.glean.com/mcp/default',\n *   headers: createGleanHeaders('my-api-token'),\n * });\n * ```\n */\nexport function createGleanRegistry(): MCPConfigRegistry {\n  return new MCPConfigRegistry(GLEAN_REGISTRY_OPTIONS);\n}\n\n/**\n * Build the Glean MCP server URL from an instance name.\n *\n * @param instance - Glean instance name (e.g., 'my-company')\n * @param endpoint - MCP endpoint (default: 'default')\n * @returns Full Glean MCP server URL\n *\n * @example\n * ```typescript\n * const url = buildGleanServerUrl('my-company');\n * // Returns: 'https://my-company-be.glean.com/mcp/default'\n *\n * const customUrl = buildGleanServerUrl('my-company', 'custom');\n * // Returns: 'https://my-company-be.glean.com/mcp/custom'\n * ```\n */\nexport function buildGleanServerUrl(instance: string, endpoint: string = 'default'): string {\n  return `https://${instance}-be.glean.com/mcp/${endpoint}`;\n}\n\n// Type helpers for Glean-specific usage\nexport type GleanEnvVars = {\n  [GLEAN_ENV.INSTANCE]?: string;\n  [GLEAN_ENV.URL]?: string;\n  [GLEAN_ENV.API_TOKEN]?: string;\n};\n\n/**\n * Options for Glean-specific connection configuration.\n * Extends MCPConnectionOptions with Glean-specific properties.\n */\nexport interface GleanConnectionOptions extends MCPConnectionOptions {\n  /** Product name for white-label support (e.g., 'Glean', 'Acme Platform') */\n  productName?: string;\n  /** Use agents endpoint instead of default */\n  agents?: boolean;\n}\n\n/**\n * Normalize a product name to a safe identifier.\n * Used for white-label support in Glean configurations.\n *\n * @param productName - Product name (e.g., 'Glean', 'Acme Platform')\n * @returns Normalized product name (e.g., 'glean', 'acme_platform')\n *\n * @example\n * ```typescript\n * normalizeGleanProductName('Glean'); // 'glean'\n * normalizeGleanProductName('Acme Platform'); // 'acme_platform'\n * normalizeGleanProductName('My-Product'); // 'my_product'\n * ```\n */\nexport function normalizeGleanProductName(productName?: string): string {\n  if (!productName) {\n    return 'glean';\n  }\n  const normalized = productName\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, '_')\n    .replace(/_+/g, '_')\n    .replace(/^_|_$/g, '');\n  return normalized || 'glean';\n}\n\n/**\n * Build a Glean-prefixed server name for MCP configurations.\n * Wraps the vendor-neutral buildMcpServerName with Glean-specific prefixing.\n *\n * Rules:\n * - If explicit serverName is provided and already has the product prefix, use it directly\n * - If explicit serverName is provided without prefix, add the product prefix\n * - If agents flag is set, return '{product}_agents'\n * - For stdio transport: '{product}_local'\n * - For http transport with URL: '{product}_{extracted-name}'\n * - Fallback: '{product}'\n *\n * @param options - Server name options\n * @returns Prefixed server name (e.g., 'glean_local', 'acme_analytics')\n *\n * @example\n * ```typescript\n * buildGleanServerName({ transport: 'stdio' }); // 'glean_local'\n * buildGleanServerName({ transport: 'http', serverUrl: '.../mcp/analytics' }); // 'glean_analytics'\n * buildGleanServerName({ transport: 'stdio', productName: 'Acme' }); // 'acme_local'\n * buildGleanServerName({ agents: true }); // 'glean_agents'\n * buildGleanServerName({ serverName: 'custom' }); // 'glean_custom'\n * ```\n */\nexport function buildGleanServerName(options: {\n  transport?: 'stdio' | 'http';\n  serverUrl?: string;\n  serverName?: string;\n  productName?: string;\n  agents?: boolean;\n}): string {\n  const productPrefix = normalizeGleanProductName(options.productName);\n\n  // Handle explicit serverName\n  if (options.serverName) {\n    // If it already has the correct prefix, use it directly\n    if (\n      options.serverName === productPrefix ||\n      options.serverName.startsWith(`${productPrefix}_`)\n    ) {\n      return options.serverName;\n    }\n    return `${productPrefix}_${options.serverName}`;\n  }\n\n  // Handle agents mode\n  if (options.agents) {\n    return `${productPrefix}_agents`;\n  }\n\n  // Get base name from vendor-neutral function\n  const baseName = buildMcpServerNameBase({\n    transport: options.transport,\n    serverUrl: options.serverUrl,\n  });\n\n  // If baseName is 'default' and we have no specific info, just return the product prefix\n  if (baseName === 'default' && !options.transport && !options.serverUrl) {\n    return productPrefix;\n  }\n\n  return `${productPrefix}_${baseName}`;\n}\n\n/**\n * Normalize a server name with Glean product prefix.\n * Ensures the server name has the correct product prefix and is safe for use as a configuration key.\n *\n * @param name - Server name to normalize\n * @param productName - Optional product name for white-label support\n * @returns Normalized server name with product prefix\n *\n * @example\n * ```typescript\n * normalizeGleanServerName('custom'); // 'glean_custom'\n * normalizeGleanServerName('glean_custom'); // 'glean_custom' (no double prefix)\n * normalizeGleanServerName('custom', 'acme'); // 'acme_custom'\n * ```\n */\nexport function normalizeGleanServerName(name: string, productName?: string): string {\n  const productPrefix = normalizeGleanProductName(productName);\n\n  if (!name) {\n    return productPrefix;\n  }\n\n  const lowerName = name.toLowerCase();\n\n  // If it already starts with the prefix, return as-is\n  if (lowerName === productPrefix || lowerName.startsWith(`${productPrefix}_`)) {\n    return lowerName;\n  }\n\n  // Handle case where name starts with just the product (e.g., 'gleancustom' -> 'glean_custom')\n  if (lowerName.startsWith(productPrefix) && lowerName.length > productPrefix.length) {\n    const rest = lowerName.slice(productPrefix.length);\n    return `${productPrefix}_${rest}`;\n  }\n\n  return `${productPrefix}_${lowerName}`;\n}\n"],"mappings":"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","names":["buildMcpServerNameBase"]}

package/dist/index.d.cts

@@ -0,0 +1,187 @@
+import { RegistryOptions, MCPConfigRegistry, MCPConnectionOptions } from '@gleanwork/mcp-config-schema';
+export * from '@gleanwork/mcp-config-schema';
+
+/**
+ * Glean-specific registry options for stdio transport.
+ */
+declare const GLEAN_REGISTRY_OPTIONS: RegistryOptions;
+/**
+ * Glean environment variable names.
+ */
+declare const GLEAN_ENV: {
+    /** Environment variable for Glean instance name (e.g., 'my-company') */
+    readonly INSTANCE: "GLEAN_INSTANCE";
+    /** Environment variable for full Glean URL (e.g., 'https://my-company.glean.com') */
+    readonly URL: "GLEAN_URL";
+    /** Environment variable for Glean API token */
+    readonly API_TOKEN: "GLEAN_API_TOKEN";
+};
+/**
+ * Helper to create Glean environment variables for stdio transport.
+ *
+ * @param instance - Glean instance name (e.g., 'my-company')
+ * @param apiToken - Optional API token
+ * @returns Environment variables object for use in MCPConnectionOptions.env
+ *
+ * @example
+ * ```typescript
+ * const config = builder.buildConfiguration({
+ *   transport: 'stdio',
+ *   env: createGleanEnv('my-company', 'my-api-token'),
+ * });
+ * ```
+ */
+declare function createGleanEnv(instance: string, apiToken?: string): Record<string, string>;
+/**
+ * Helper to create Glean environment variables using a full URL.
+ *
+ * @param url - Full Glean URL (e.g., 'https://my-company.glean.com')
+ * @param apiToken - Optional API token
+ * @returns Environment variables object for use in MCPConnectionOptions.env
+ *
+ * @example
+ * ```typescript
+ * const config = builder.buildConfiguration({
+ *   transport: 'stdio',
+ *   env: createGleanUrlEnv('https://my-company.glean.com', 'my-api-token'),
+ * });
+ * ```
+ */
+declare function createGleanUrlEnv(url: string, apiToken?: string): Record<string, string>;
+/**
+ * Helper to create Glean authorization headers for HTTP transport.
+ *
+ * @param apiToken - Glean API token
+ * @returns Headers object for use in MCPConnectionOptions.headers
+ *
+ * @example
+ * ```typescript
+ * const config = builder.buildConfiguration({
+ *   transport: 'http',
+ *   serverUrl: 'https://my-company-be.glean.com/mcp/default',
+ *   headers: createGleanHeaders('my-api-token'),
+ * });
+ * ```
+ */
+declare function createGleanHeaders(apiToken: string): Record<string, string>;
+/**
+ * Create an MCPConfigRegistry pre-configured with Glean defaults.
+ *
+ * @returns MCPConfigRegistry configured for Glean stdio transport
+ *
+ * @example
+ * ```typescript
+ * const registry = createGleanRegistry();
+ * const builder = registry.createBuilder('cursor');
+ *
+ * // For stdio transport
+ * const config = builder.buildConfiguration({
+ *   transport: 'stdio',
+ *   env: createGleanEnv('my-company', 'my-api-token'),
+ * });
+ *
+ * // For HTTP transport
+ * const httpConfig = builder.buildConfiguration({
+ *   transport: 'http',
+ *   serverUrl: 'https://my-company-be.glean.com/mcp/default',
+ *   headers: createGleanHeaders('my-api-token'),
+ * });
+ * ```
+ */
+declare function createGleanRegistry(): MCPConfigRegistry;
+/**
+ * Build the Glean MCP server URL from an instance name.
+ *
+ * @param instance - Glean instance name (e.g., 'my-company')
+ * @param endpoint - MCP endpoint (default: 'default')
+ * @returns Full Glean MCP server URL
+ *
+ * @example
+ * ```typescript
+ * const url = buildGleanServerUrl('my-company');
+ * // Returns: 'https://my-company-be.glean.com/mcp/default'
+ *
+ * const customUrl = buildGleanServerUrl('my-company', 'custom');
+ * // Returns: 'https://my-company-be.glean.com/mcp/custom'
+ * ```
+ */
+declare function buildGleanServerUrl(instance: string, endpoint?: string): string;
+type GleanEnvVars = {
+    [GLEAN_ENV.INSTANCE]?: string;
+    [GLEAN_ENV.URL]?: string;
+    [GLEAN_ENV.API_TOKEN]?: string;
+};
+/**
+ * Options for Glean-specific connection configuration.
+ * Extends MCPConnectionOptions with Glean-specific properties.
+ */
+interface GleanConnectionOptions extends MCPConnectionOptions {
+    /** Product name for white-label support (e.g., 'Glean', 'Acme Platform') */
+    productName?: string;
+    /** Use agents endpoint instead of default */
+    agents?: boolean;
+}
+/**
+ * Normalize a product name to a safe identifier.
+ * Used for white-label support in Glean configurations.
+ *
+ * @param productName - Product name (e.g., 'Glean', 'Acme Platform')
+ * @returns Normalized product name (e.g., 'glean', 'acme_platform')
+ *
+ * @example
+ * ```typescript
+ * normalizeGleanProductName('Glean'); // 'glean'
+ * normalizeGleanProductName('Acme Platform'); // 'acme_platform'
+ * normalizeGleanProductName('My-Product'); // 'my_product'
+ * ```
+ */
+declare function normalizeGleanProductName(productName?: string): string;
+/**
+ * Build a Glean-prefixed server name for MCP configurations.
+ * Wraps the vendor-neutral buildMcpServerName with Glean-specific prefixing.
+ *
+ * Rules:
+ * - If explicit serverName is provided and already has the product prefix, use it directly
+ * - If explicit serverName is provided without prefix, add the product prefix
+ * - If agents flag is set, return '{product}_agents'
+ * - For stdio transport: '{product}_local'
+ * - For http transport with URL: '{product}_{extracted-name}'
+ * - Fallback: '{product}'
+ *
+ * @param options - Server name options
+ * @returns Prefixed server name (e.g., 'glean_local', 'acme_analytics')
+ *
+ * @example
+ * ```typescript
+ * buildGleanServerName({ transport: 'stdio' }); // 'glean_local'
+ * buildGleanServerName({ transport: 'http', serverUrl: '.../mcp/analytics' }); // 'glean_analytics'
+ * buildGleanServerName({ transport: 'stdio', productName: 'Acme' }); // 'acme_local'
+ * buildGleanServerName({ agents: true }); // 'glean_agents'
+ * buildGleanServerName({ serverName: 'custom' }); // 'glean_custom'
+ * ```
+ */
+declare function buildGleanServerName(options: {
+    transport?: 'stdio' | 'http';
+    serverUrl?: string;
+    serverName?: string;
+    productName?: string;
+    agents?: boolean;
+}): string;
+/**
+ * Normalize a server name with Glean product prefix.
+ * Ensures the server name has the correct product prefix and is safe for use as a configuration key.
+ *
+ * @param name - Server name to normalize
+ * @param productName - Optional product name for white-label support
+ * @returns Normalized server name with product prefix
+ *
+ * @example
+ * ```typescript
+ * normalizeGleanServerName('custom'); // 'glean_custom'
+ * normalizeGleanServerName('glean_custom'); // 'glean_custom' (no double prefix)
+ * normalizeGleanServerName('custom', 'acme'); // 'acme_custom'
+ * ```
+ */
+declare function normalizeGleanServerName(name: string, productName?: string): string;
+
+export { GLEAN_ENV, GLEAN_REGISTRY_OPTIONS, type GleanConnectionOptions, type GleanEnvVars, buildGleanServerName, buildGleanServerUrl, createGleanEnv, createGleanHeaders, createGleanRegistry, createGleanUrlEnv, normalizeGleanProductName, normalizeGleanServerName };

package/dist/index.d.ts

@@ -0,0 +1,187 @@
+import { RegistryOptions, MCPConfigRegistry, MCPConnectionOptions } from '@gleanwork/mcp-config-schema';
+export * from '@gleanwork/mcp-config-schema';
+
+/**
+ * Glean-specific registry options for stdio transport.
+ */
+declare const GLEAN_REGISTRY_OPTIONS: RegistryOptions;
+/**
+ * Glean environment variable names.
+ */
+declare const GLEAN_ENV: {
+    /** Environment variable for Glean instance name (e.g., 'my-company') */
+    readonly INSTANCE: "GLEAN_INSTANCE";
+    /** Environment variable for full Glean URL (e.g., 'https://my-company.glean.com') */
+    readonly URL: "GLEAN_URL";
+    /** Environment variable for Glean API token */
+    readonly API_TOKEN: "GLEAN_API_TOKEN";
+};
+/**
+ * Helper to create Glean environment variables for stdio transport.
+ *
+ * @param instance - Glean instance name (e.g., 'my-company')
+ * @param apiToken - Optional API token
+ * @returns Environment variables object for use in MCPConnectionOptions.env
+ *
+ * @example
+ * ```typescript
+ * const config = builder.buildConfiguration({
+ *   transport: 'stdio',
+ *   env: createGleanEnv('my-company', 'my-api-token'),
+ * });
+ * ```
+ */
+declare function createGleanEnv(instance: string, apiToken?: string): Record<string, string>;
+/**
+ * Helper to create Glean environment variables using a full URL.
+ *
+ * @param url - Full Glean URL (e.g., 'https://my-company.glean.com')
+ * @param apiToken - Optional API token
+ * @returns Environment variables object for use in MCPConnectionOptions.env
+ *
+ * @example
+ * ```typescript
+ * const config = builder.buildConfiguration({
+ *   transport: 'stdio',
+ *   env: createGleanUrlEnv('https://my-company.glean.com', 'my-api-token'),
+ * });
+ * ```
+ */
+declare function createGleanUrlEnv(url: string, apiToken?: string): Record<string, string>;
+/**
+ * Helper to create Glean authorization headers for HTTP transport.
+ *
+ * @param apiToken - Glean API token
+ * @returns Headers object for use in MCPConnectionOptions.headers
+ *
+ * @example
+ * ```typescript
+ * const config = builder.buildConfiguration({
+ *   transport: 'http',
+ *   serverUrl: 'https://my-company-be.glean.com/mcp/default',
+ *   headers: createGleanHeaders('my-api-token'),
+ * });
+ * ```
+ */
+declare function createGleanHeaders(apiToken: string): Record<string, string>;
+/**
+ * Create an MCPConfigRegistry pre-configured with Glean defaults.
+ *
+ * @returns MCPConfigRegistry configured for Glean stdio transport
+ *
+ * @example
+ * ```typescript
+ * const registry = createGleanRegistry();
+ * const builder = registry.createBuilder('cursor');
+ *
+ * // For stdio transport
+ * const config = builder.buildConfiguration({
+ *   transport: 'stdio',
+ *   env: createGleanEnv('my-company', 'my-api-token'),
+ * });
+ *
+ * // For HTTP transport
+ * const httpConfig = builder.buildConfiguration({
+ *   transport: 'http',
+ *   serverUrl: 'https://my-company-be.glean.com/mcp/default',
+ *   headers: createGleanHeaders('my-api-token'),
+ * });
+ * ```
+ */
+declare function createGleanRegistry(): MCPConfigRegistry;
+/**
+ * Build the Glean MCP server URL from an instance name.
+ *
+ * @param instance - Glean instance name (e.g., 'my-company')
+ * @param endpoint - MCP endpoint (default: 'default')
+ * @returns Full Glean MCP server URL
+ *
+ * @example
+ * ```typescript
+ * const url = buildGleanServerUrl('my-company');
+ * // Returns: 'https://my-company-be.glean.com/mcp/default'
+ *
+ * const customUrl = buildGleanServerUrl('my-company', 'custom');
+ * // Returns: 'https://my-company-be.glean.com/mcp/custom'
+ * ```
+ */
+declare function buildGleanServerUrl(instance: string, endpoint?: string): string;
+type GleanEnvVars = {
+    [GLEAN_ENV.INSTANCE]?: string;
+    [GLEAN_ENV.URL]?: string;
+    [GLEAN_ENV.API_TOKEN]?: string;
+};
+/**
+ * Options for Glean-specific connection configuration.
+ * Extends MCPConnectionOptions with Glean-specific properties.
+ */
+interface GleanConnectionOptions extends MCPConnectionOptions {
+    /** Product name for white-label support (e.g., 'Glean', 'Acme Platform') */
+    productName?: string;
+    /** Use agents endpoint instead of default */
+    agents?: boolean;
+}
+/**
+ * Normalize a product name to a safe identifier.
+ * Used for white-label support in Glean configurations.
+ *
+ * @param productName - Product name (e.g., 'Glean', 'Acme Platform')
+ * @returns Normalized product name (e.g., 'glean', 'acme_platform')
+ *
+ * @example
+ * ```typescript
+ * normalizeGleanProductName('Glean'); // 'glean'
+ * normalizeGleanProductName('Acme Platform'); // 'acme_platform'
+ * normalizeGleanProductName('My-Product'); // 'my_product'
+ * ```
+ */
+declare function normalizeGleanProductName(productName?: string): string;
+/**
+ * Build a Glean-prefixed server name for MCP configurations.
+ * Wraps the vendor-neutral buildMcpServerName with Glean-specific prefixing.
+ *
+ * Rules:
+ * - If explicit serverName is provided and already has the product prefix, use it directly
+ * - If explicit serverName is provided without prefix, add the product prefix
+ * - If agents flag is set, return '{product}_agents'
+ * - For stdio transport: '{product}_local'
+ * - For http transport with URL: '{product}_{extracted-name}'
+ * - Fallback: '{product}'
+ *
+ * @param options - Server name options
+ * @returns Prefixed server name (e.g., 'glean_local', 'acme_analytics')
+ *
+ * @example
+ * ```typescript
+ * buildGleanServerName({ transport: 'stdio' }); // 'glean_local'
+ * buildGleanServerName({ transport: 'http', serverUrl: '.../mcp/analytics' }); // 'glean_analytics'
+ * buildGleanServerName({ transport: 'stdio', productName: 'Acme' }); // 'acme_local'
+ * buildGleanServerName({ agents: true }); // 'glean_agents'
+ * buildGleanServerName({ serverName: 'custom' }); // 'glean_custom'
+ * ```
+ */
+declare function buildGleanServerName(options: {
+    transport?: 'stdio' | 'http';
+    serverUrl?: string;
+    serverName?: string;
+    productName?: string;
+    agents?: boolean;
+}): string;
+/**
+ * Normalize a server name with Glean product prefix.
+ * Ensures the server name has the correct product prefix and is safe for use as a configuration key.
+ *
+ * @param name - Server name to normalize
+ * @param productName - Optional product name for white-label support
+ * @returns Normalized server name with product prefix
+ *
+ * @example
+ * ```typescript
+ * normalizeGleanServerName('custom'); // 'glean_custom'
+ * normalizeGleanServerName('glean_custom'); // 'glean_custom' (no double prefix)
+ * normalizeGleanServerName('custom', 'acme'); // 'acme_custom'
+ * ```
+ */
+declare function normalizeGleanServerName(name: string, productName?: string): string;
+
+export { GLEAN_ENV, GLEAN_REGISTRY_OPTIONS, type GleanConnectionOptions, type GleanEnvVars, buildGleanServerName, buildGleanServerUrl, createGleanEnv, createGleanHeaders, createGleanRegistry, createGleanUrlEnv, normalizeGleanProductName, normalizeGleanServerName };

package/dist/index.js

@@ -0,0 +1,108 @@
+// src/index.ts
+import {
+  MCPConfigRegistry,
+  buildMcpServerName as buildMcpServerNameBase
+} from "@gleanwork/mcp-config-schema";
+export * from "@gleanwork/mcp-config-schema";
+var GLEAN_REGISTRY_OPTIONS = {
+  serverPackage: "@gleanwork/local-mcp-server",
+  commandBuilder: {
+    http: (clientId, options) => {
+      if (!options.serverUrl) return null;
+      return `npx -y @gleanwork/configure-mcp-server remote --url ${options.serverUrl} --client ${clientId}`;
+    },
+    stdio: (clientId, options) => {
+      const envFlags = Object.entries(options.env || {}).map(([k, v]) => `--env ${k}=${v}`).join(" ");
+      return `npx -y @gleanwork/configure-mcp-server local --client ${clientId}${envFlags ? ` ${envFlags}` : ""}`;
+    }
+  },
+  serverNameBuilder: (options) => {
+    return buildGleanServerName(options);
+  }
+};
+var GLEAN_ENV = {
+  /** Environment variable for Glean instance name (e.g., 'my-company') */
+  INSTANCE: "GLEAN_INSTANCE",
+  /** Environment variable for full Glean URL (e.g., 'https://my-company.glean.com') */
+  URL: "GLEAN_URL",
+  /** Environment variable for Glean API token */
+  API_TOKEN: "GLEAN_API_TOKEN"
+};
+function createGleanEnv(instance, apiToken) {
+  return {
+    [GLEAN_ENV.INSTANCE]: instance,
+    ...apiToken && { [GLEAN_ENV.API_TOKEN]: apiToken }
+  };
+}
+function createGleanUrlEnv(url, apiToken) {
+  return {
+    [GLEAN_ENV.URL]: url,
+    ...apiToken && { [GLEAN_ENV.API_TOKEN]: apiToken }
+  };
+}
+function createGleanHeaders(apiToken) {
+  return {
+    Authorization: `Bearer ${apiToken}`
+  };
+}
+function createGleanRegistry() {
+  return new MCPConfigRegistry(GLEAN_REGISTRY_OPTIONS);
+}
+function buildGleanServerUrl(instance, endpoint = "default") {
+  return `https://${instance}-be.glean.com/mcp/${endpoint}`;
+}
+function normalizeGleanProductName(productName) {
+  if (!productName) {
+    return "glean";
+  }
+  const normalized = productName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  return normalized || "glean";
+}
+function buildGleanServerName(options) {
+  const productPrefix = normalizeGleanProductName(options.productName);
+  if (options.serverName) {
+    if (options.serverName === productPrefix || options.serverName.startsWith(`${productPrefix}_`)) {
+      return options.serverName;
+    }
+    return `${productPrefix}_${options.serverName}`;
+  }
+  if (options.agents) {
+    return `${productPrefix}_agents`;
+  }
+  const baseName = buildMcpServerNameBase({
+    transport: options.transport,
+    serverUrl: options.serverUrl
+  });
+  if (baseName === "default" && !options.transport && !options.serverUrl) {
+    return productPrefix;
+  }
+  return `${productPrefix}_${baseName}`;
+}
+function normalizeGleanServerName(name, productName) {
+  const productPrefix = normalizeGleanProductName(productName);
+  if (!name) {
+    return productPrefix;
+  }
+  const lowerName = name.toLowerCase();
+  if (lowerName === productPrefix || lowerName.startsWith(`${productPrefix}_`)) {
+    return lowerName;
+  }
+  if (lowerName.startsWith(productPrefix) && lowerName.length > productPrefix.length) {
+    const rest = lowerName.slice(productPrefix.length);
+    return `${productPrefix}_${rest}`;
+  }
+  return `${productPrefix}_${lowerName}`;
+}
+export {
+  GLEAN_ENV,
+  GLEAN_REGISTRY_OPTIONS,
+  buildGleanServerName,
+  buildGleanServerUrl,
+  createGleanEnv,
+  createGleanHeaders,
+  createGleanRegistry,
+  createGleanUrlEnv,
+  normalizeGleanProductName,
+  normalizeGleanServerName
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {\n  MCPConfigRegistry,\n  buildMcpServerName as buildMcpServerNameBase,\n  type MCPConnectionOptions,\n  type RegistryOptions,\n} from '@gleanwork/mcp-config-schema';\n\n// Re-export everything from the base package for convenience\nexport * from '@gleanwork/mcp-config-schema';\n\n/**\n * Glean-specific registry options for stdio transport.\n */\nexport const GLEAN_REGISTRY_OPTIONS: RegistryOptions = {\n  serverPackage: '@gleanwork/local-mcp-server',\n  commandBuilder: {\n    http: (clientId, options) => {\n      if (!options.serverUrl) return null;\n      return `npx -y @gleanwork/configure-mcp-server remote --url ${options.serverUrl} --client ${clientId}`;\n    },\n    stdio: (clientId, options) => {\n      const envFlags = Object.entries(options.env || {})\n        .map(([k, v]) => `--env ${k}=${v}`)\n        .join(' ');\n      return `npx -y @gleanwork/configure-mcp-server local --client ${clientId}${envFlags ? ` ${envFlags}` : ''}`;\n    },\n  },\n  serverNameBuilder: (options) => {\n    // Lazily call buildGleanServerName defined below\n    return buildGleanServerName(options);\n  },\n};\n\n/**\n * Glean environment variable names.\n */\nexport const GLEAN_ENV = {\n  /** Environment variable for Glean instance name (e.g., 'my-company') */\n  INSTANCE: 'GLEAN_INSTANCE',\n  /** Environment variable for full Glean URL (e.g., 'https://my-company.glean.com') */\n  URL: 'GLEAN_URL',\n  /** Environment variable for Glean API token */\n  API_TOKEN: 'GLEAN_API_TOKEN',\n} as const;\n\n/**\n * Helper to create Glean environment variables for stdio transport.\n *\n * @param instance - Glean instance name (e.g., 'my-company')\n * @param apiToken - Optional API token\n * @returns Environment variables object for use in MCPConnectionOptions.env\n *\n * @example\n * ```typescript\n * const config = builder.buildConfiguration({\n *   transport: 'stdio',\n *   env: createGleanEnv('my-company', 'my-api-token'),\n * });\n * ```\n */\nexport function createGleanEnv(instance: string, apiToken?: string): Record<string, string> {\n  return {\n    [GLEAN_ENV.INSTANCE]: instance,\n    ...(apiToken && { [GLEAN_ENV.API_TOKEN]: apiToken }),\n  };\n}\n\n/**\n * Helper to create Glean environment variables using a full URL.\n *\n * @param url - Full Glean URL (e.g., 'https://my-company.glean.com')\n * @param apiToken - Optional API token\n * @returns Environment variables object for use in MCPConnectionOptions.env\n *\n * @example\n * ```typescript\n * const config = builder.buildConfiguration({\n *   transport: 'stdio',\n *   env: createGleanUrlEnv('https://my-company.glean.com', 'my-api-token'),\n * });\n * ```\n */\nexport function createGleanUrlEnv(url: string, apiToken?: string): Record<string, string> {\n  return {\n    [GLEAN_ENV.URL]: url,\n    ...(apiToken && { [GLEAN_ENV.API_TOKEN]: apiToken }),\n  };\n}\n\n/**\n * Helper to create Glean authorization headers for HTTP transport.\n *\n * @param apiToken - Glean API token\n * @returns Headers object for use in MCPConnectionOptions.headers\n *\n * @example\n * ```typescript\n * const config = builder.buildConfiguration({\n *   transport: 'http',\n *   serverUrl: 'https://my-company-be.glean.com/mcp/default',\n *   headers: createGleanHeaders('my-api-token'),\n * });\n * ```\n */\nexport function createGleanHeaders(apiToken: string): Record<string, string> {\n  return {\n    Authorization: `Bearer ${apiToken}`,\n  };\n}\n\n/**\n * Create an MCPConfigRegistry pre-configured with Glean defaults.\n *\n * @returns MCPConfigRegistry configured for Glean stdio transport\n *\n * @example\n * ```typescript\n * const registry = createGleanRegistry();\n * const builder = registry.createBuilder('cursor');\n *\n * // For stdio transport\n * const config = builder.buildConfiguration({\n *   transport: 'stdio',\n *   env: createGleanEnv('my-company', 'my-api-token'),\n * });\n *\n * // For HTTP transport\n * const httpConfig = builder.buildConfiguration({\n *   transport: 'http',\n *   serverUrl: 'https://my-company-be.glean.com/mcp/default',\n *   headers: createGleanHeaders('my-api-token'),\n * });\n * ```\n */\nexport function createGleanRegistry(): MCPConfigRegistry {\n  return new MCPConfigRegistry(GLEAN_REGISTRY_OPTIONS);\n}\n\n/**\n * Build the Glean MCP server URL from an instance name.\n *\n * @param instance - Glean instance name (e.g., 'my-company')\n * @param endpoint - MCP endpoint (default: 'default')\n * @returns Full Glean MCP server URL\n *\n * @example\n * ```typescript\n * const url = buildGleanServerUrl('my-company');\n * // Returns: 'https://my-company-be.glean.com/mcp/default'\n *\n * const customUrl = buildGleanServerUrl('my-company', 'custom');\n * // Returns: 'https://my-company-be.glean.com/mcp/custom'\n * ```\n */\nexport function buildGleanServerUrl(instance: string, endpoint: string = 'default'): string {\n  return `https://${instance}-be.glean.com/mcp/${endpoint}`;\n}\n\n// Type helpers for Glean-specific usage\nexport type GleanEnvVars = {\n  [GLEAN_ENV.INSTANCE]?: string;\n  [GLEAN_ENV.URL]?: string;\n  [GLEAN_ENV.API_TOKEN]?: string;\n};\n\n/**\n * Options for Glean-specific connection configuration.\n * Extends MCPConnectionOptions with Glean-specific properties.\n */\nexport interface GleanConnectionOptions extends MCPConnectionOptions {\n  /** Product name for white-label support (e.g., 'Glean', 'Acme Platform') */\n  productName?: string;\n  /** Use agents endpoint instead of default */\n  agents?: boolean;\n}\n\n/**\n * Normalize a product name to a safe identifier.\n * Used for white-label support in Glean configurations.\n *\n * @param productName - Product name (e.g., 'Glean', 'Acme Platform')\n * @returns Normalized product name (e.g., 'glean', 'acme_platform')\n *\n * @example\n * ```typescript\n * normalizeGleanProductName('Glean'); // 'glean'\n * normalizeGleanProductName('Acme Platform'); // 'acme_platform'\n * normalizeGleanProductName('My-Product'); // 'my_product'\n * ```\n */\nexport function normalizeGleanProductName(productName?: string): string {\n  if (!productName) {\n    return 'glean';\n  }\n  const normalized = productName\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, '_')\n    .replace(/_+/g, '_')\n    .replace(/^_|_$/g, '');\n  return normalized || 'glean';\n}\n\n/**\n * Build a Glean-prefixed server name for MCP configurations.\n * Wraps the vendor-neutral buildMcpServerName with Glean-specific prefixing.\n *\n * Rules:\n * - If explicit serverName is provided and already has the product prefix, use it directly\n * - If explicit serverName is provided without prefix, add the product prefix\n * - If agents flag is set, return '{product}_agents'\n * - For stdio transport: '{product}_local'\n * - For http transport with URL: '{product}_{extracted-name}'\n * - Fallback: '{product}'\n *\n * @param options - Server name options\n * @returns Prefixed server name (e.g., 'glean_local', 'acme_analytics')\n *\n * @example\n * ```typescript\n * buildGleanServerName({ transport: 'stdio' }); // 'glean_local'\n * buildGleanServerName({ transport: 'http', serverUrl: '.../mcp/analytics' }); // 'glean_analytics'\n * buildGleanServerName({ transport: 'stdio', productName: 'Acme' }); // 'acme_local'\n * buildGleanServerName({ agents: true }); // 'glean_agents'\n * buildGleanServerName({ serverName: 'custom' }); // 'glean_custom'\n * ```\n */\nexport function buildGleanServerName(options: {\n  transport?: 'stdio' | 'http';\n  serverUrl?: string;\n  serverName?: string;\n  productName?: string;\n  agents?: boolean;\n}): string {\n  const productPrefix = normalizeGleanProductName(options.productName);\n\n  // Handle explicit serverName\n  if (options.serverName) {\n    // If it already has the correct prefix, use it directly\n    if (\n      options.serverName === productPrefix ||\n      options.serverName.startsWith(`${productPrefix}_`)\n    ) {\n      return options.serverName;\n    }\n    return `${productPrefix}_${options.serverName}`;\n  }\n\n  // Handle agents mode\n  if (options.agents) {\n    return `${productPrefix}_agents`;\n  }\n\n  // Get base name from vendor-neutral function\n  const baseName = buildMcpServerNameBase({\n    transport: options.transport,\n    serverUrl: options.serverUrl,\n  });\n\n  // If baseName is 'default' and we have no specific info, just return the product prefix\n  if (baseName === 'default' && !options.transport && !options.serverUrl) {\n    return productPrefix;\n  }\n\n  return `${productPrefix}_${baseName}`;\n}\n\n/**\n * Normalize a server name with Glean product prefix.\n * Ensures the server name has the correct product prefix and is safe for use as a configuration key.\n *\n * @param name - Server name to normalize\n * @param productName - Optional product name for white-label support\n * @returns Normalized server name with product prefix\n *\n * @example\n * ```typescript\n * normalizeGleanServerName('custom'); // 'glean_custom'\n * normalizeGleanServerName('glean_custom'); // 'glean_custom' (no double prefix)\n * normalizeGleanServerName('custom', 'acme'); // 'acme_custom'\n * ```\n */\nexport function normalizeGleanServerName(name: string, productName?: string): string {\n  const productPrefix = normalizeGleanProductName(productName);\n\n  if (!name) {\n    return productPrefix;\n  }\n\n  const lowerName = name.toLowerCase();\n\n  // If it already starts with the prefix, return as-is\n  if (lowerName === productPrefix || lowerName.startsWith(`${productPrefix}_`)) {\n    return lowerName;\n  }\n\n  // Handle case where name starts with just the product (e.g., 'gleancustom' -> 'glean_custom')\n  if (lowerName.startsWith(productPrefix) && lowerName.length > productPrefix.length) {\n    const rest = lowerName.slice(productPrefix.length);\n    return `${productPrefix}_${rest}`;\n  }\n\n  return `${productPrefix}_${lowerName}`;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@gleanwork/mcp-config",
+  "version": "0.5.0",
+  "description": "Glean-specific MCP configuration defaults and helpers",
+  "keywords": [
+    "mcp",
+    "glean",
+    "configuration"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:gleanwork/mcp-config.git"
+  },
+  "license": "MIT",
+  "author": "Glean",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "lint": "npm-run-all --sequential lint:*",
+    "lint:eslint": "eslint src --ext ts --fix",
+    "lint:package-json": "sort-package-json",
+    "test": "vitest run",
+    "test:all": "npm run lint && npm run typecheck && npm run test",
+    "format": "prettier --write '**/*.ts'",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@gleanwork/mcp-config-schema": "^3.0.0-beta.0"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.3",
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^22.15.21",
+    "@typescript-eslint/eslint-plugin": "^8.51.0",
+    "@typescript-eslint/parser": "^8.51.0",
+    "eslint": "^9.28.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^17.0.0",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^3.7.4",
+    "sort-package-json": "^3.6.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  }
+}