@arabold/docs-mcp-server 2.0.3 → 2.1.0

package/dist/utils-XwXdQlZ_.js

@@ -0,0 +1,1062 @@
+import { execSync } from "node:child_process";
+import fs, { existsSync } from "node:fs";
+import { chromium } from "playwright";
+import EventEmitter from "node:events";
+import { l as logger, n as normalizeEnvValue } from "./logger-CLtABTNb.js";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import envPaths from "env-paths";
+import { PostHog } from "posthog-node";
+let projectRoot = null;
+function getProjectRoot() {
+  if (projectRoot) {
+    return projectRoot;
+  }
+  const currentFilePath = fileURLToPath(import.meta.url);
+  let currentDir = path.dirname(currentFilePath);
+  while (true) {
+    const packageJsonPath = path.join(currentDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      projectRoot = currentDir;
+      return currentDir;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      throw new Error("Could not find project root containing package.json.");
+    }
+    currentDir = parentDir;
+  }
+}
+function resolveStorePath(storePath) {
+  let dbDir;
+  if (storePath) {
+    dbDir = path.resolve(storePath);
+  } else {
+    const projectRoot2 = getProjectRoot();
+    const oldDbDir = path.join(projectRoot2, ".store");
+    const oldDbPath = path.join(oldDbDir, "documents.db");
+    const oldDbExists = fs.existsSync(oldDbPath);
+    if (oldDbExists) {
+      dbDir = oldDbDir;
+    } else {
+      const standardPaths = envPaths("docs-mcp-server", { suffix: "" });
+      dbDir = standardPaths.data;
+    }
+  }
+  try {
+    fs.mkdirSync(dbDir, { recursive: true });
+  } catch (error) {
+    logger.warn(`⚠️  Failed to create database directory ${dbDir}: ${error}`);
+  }
+  return dbDir;
+}
+class TelemetryConfig {
+  static instance;
+  enabled = true;
+  // Default to enabled
+  constructor() {
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  static getInstance() {
+    if (!TelemetryConfig.instance) {
+      TelemetryConfig.instance = new TelemetryConfig();
+    }
+    return TelemetryConfig.instance;
+  }
+}
+function generateInstallationId(storePath) {
+  try {
+    const dataDir = resolveStorePath(storePath);
+    const installationIdPath = path.join(dataDir, "installation.id");
+    if (fs.existsSync(installationIdPath)) {
+      const existingId = fs.readFileSync(installationIdPath, "utf8").trim();
+      if (existingId) {
+        return existingId;
+      }
+    }
+    const newId = randomUUID();
+    fs.mkdirSync(dataDir, { recursive: true });
+    fs.writeFileSync(installationIdPath, newId, "utf8");
+    return newId;
+  } catch {
+    return randomUUID();
+  }
+}
+function shouldEnableTelemetry() {
+  return TelemetryConfig.getInstance().isEnabled();
+}
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["JOB_STATUS_CHANGE"] = "JOB_STATUS_CHANGE";
+  EventType2["JOB_PROGRESS"] = "JOB_PROGRESS";
+  EventType2["LIBRARY_CHANGE"] = "LIBRARY_CHANGE";
+  EventType2["JOB_LIST_CHANGE"] = "JOB_LIST_CHANGE";
+  return EventType2;
+})(EventType || {});
+const ServerEventName = {
+  [
+    "JOB_STATUS_CHANGE"
+    /* JOB_STATUS_CHANGE */
+  ]: "job-status-change",
+  [
+    "JOB_PROGRESS"
+    /* JOB_PROGRESS */
+  ]: "job-progress",
+  [
+    "LIBRARY_CHANGE"
+    /* LIBRARY_CHANGE */
+  ]: "library-change",
+  [
+    "JOB_LIST_CHANGE"
+    /* JOB_LIST_CHANGE */
+  ]: "job-list-change"
+};
+var PipelineJobStatus = /* @__PURE__ */ ((PipelineJobStatus2) => {
+  PipelineJobStatus2["QUEUED"] = "queued";
+  PipelineJobStatus2["RUNNING"] = "running";
+  PipelineJobStatus2["COMPLETED"] = "completed";
+  PipelineJobStatus2["FAILED"] = "failed";
+  PipelineJobStatus2["CANCELLING"] = "cancelling";
+  PipelineJobStatus2["CANCELLED"] = "cancelled";
+  return PipelineJobStatus2;
+})(PipelineJobStatus || {});
+function camelToSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function convertPropertiesToSnakeCase(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const snakeKey = camelToSnakeCase(key);
+    if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+      result[snakeKey] = convertPropertiesToSnakeCase(value);
+    } else if (Array.isArray(value)) {
+      result[snakeKey] = value.map(
+        (item) => item && typeof item === "object" && !(item instanceof Date) ? convertPropertiesToSnakeCase(item) : item
+      );
+    } else {
+      result[snakeKey] = value;
+    }
+  }
+  return result;
+}
+function addPostHogStandardProperties(properties) {
+  const result = { ...properties };
+  if (properties.sessionId) {
+    result.$session_id = properties.sessionId;
+    delete result.sessionId;
+  }
+  if (properties.startTime) {
+    result.$start_timestamp = properties.startTime.toISOString();
+    delete result.startTime;
+  }
+  if (properties.appVersion) {
+    result.$app_version = properties.appVersion;
+    delete result.appVersion;
+  }
+  return result;
+}
+class PostHogClient {
+  client;
+  enabled;
+  // PostHog configuration
+  static CONFIG = {
+    host: "https://app.posthog.com",
+    // Performance optimizations
+    flushAt: 20,
+    // Batch size - send after 20 events
+    flushInterval: 1e4,
+    // 10 seconds - send after time
+    // Privacy settings
+    disableGeoip: true,
+    // Don't collect IP geolocation
+    disableSessionRecording: true,
+    // Never record sessions
+    disableSurveys: true,
+    // No user surveys
+    // Data handling
+    persistence: "memory"
+    // No disk persistence for privacy
+  };
+  constructor(enabled) {
+    this.enabled = enabled;
+    if (!this.enabled) {
+      return;
+    }
+    try {
+      this.client = new PostHog("phc_g7pXZZdUiAQXdnwUANjloQWMvO0amEDTBaeDSWgXgrQ", {
+        host: PostHogClient.CONFIG.host,
+        flushAt: PostHogClient.CONFIG.flushAt,
+        flushInterval: PostHogClient.CONFIG.flushInterval,
+        disableGeoip: PostHogClient.CONFIG.disableGeoip
+      });
+      logger.debug("PostHog client initialized");
+    } catch (error) {
+      logger.debug(
+        `PostHog initialization failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      this.enabled = false;
+    }
+  }
+  /**
+   * Send event to PostHog
+   */
+  capture(distinctId, event, properties) {
+    if (!this.enabled || !this.client) return;
+    try {
+      const enhancedProperties = addPostHogStandardProperties(properties);
+      const snakeCaseProperties = convertPropertiesToSnakeCase(enhancedProperties);
+      this.client.capture({
+        distinctId,
+        event,
+        properties: snakeCaseProperties
+      });
+      logger.debug(`PostHog event captured: ${event}`);
+    } catch (error) {
+      logger.debug(
+        `PostHog capture error: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Capture exception using PostHog's native error tracking
+   */
+  captureException(distinctId, error, properties) {
+    if (!this.enabled || !this.client) return;
+    try {
+      const enhancedProperties = addPostHogStandardProperties(properties || {});
+      const snakeCaseProperties = convertPropertiesToSnakeCase(enhancedProperties);
+      this.client.captureException({
+        error,
+        distinctId,
+        properties: snakeCaseProperties
+      });
+      logger.debug(`PostHog exception captured: ${error.constructor.name}`);
+    } catch (captureError) {
+      logger.debug(
+        `PostHog captureException error: ${captureError instanceof Error ? captureError.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Graceful shutdown with event flushing
+   */
+  async shutdown() {
+    if (this.client) {
+      try {
+        await this.client.shutdown();
+        logger.debug("PostHog client shutdown complete");
+      } catch (error) {
+        logger.debug(
+          `PostHog shutdown error: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+  }
+  /**
+   * Check if client is enabled and ready
+   */
+  isEnabled() {
+    return this.enabled && !!this.client;
+  }
+}
+var TelemetryEvent = /* @__PURE__ */ ((TelemetryEvent2) => {
+  TelemetryEvent2["APP_STARTED"] = "app_started";
+  TelemetryEvent2["APP_SHUTDOWN"] = "app_shutdown";
+  TelemetryEvent2["CLI_COMMAND"] = "cli_command";
+  TelemetryEvent2["TOOL_USED"] = "tool_used";
+  TelemetryEvent2["PIPELINE_JOB_STARTED"] = "pipeline_job_started";
+  TelemetryEvent2["PIPELINE_JOB_COMPLETED"] = "pipeline_job_completed";
+  TelemetryEvent2["PIPELINE_JOB_FAILED"] = "pipeline_job_failed";
+  return TelemetryEvent2;
+})(TelemetryEvent || {});
+class Telemetry {
+  postHogClient;
+  enabled;
+  distinctId;
+  globalContext = {};
+  /**
+   * Create a new Telemetry instance with proper initialization
+   * This is the recommended way to create Telemetry instances
+   */
+  static create() {
+    const config = TelemetryConfig.getInstance();
+    const shouldEnable = config.isEnabled() && true;
+    const telemetry2 = new Telemetry(shouldEnable);
+    if (telemetry2.isEnabled()) {
+      logger.debug("Telemetry enabled");
+    } else if (!config.isEnabled()) {
+      logger.debug("Telemetry disabled (user preference)");
+    } else {
+      logger.debug("Telemetry disabled");
+    }
+    return telemetry2;
+  }
+  /**
+   * Private constructor - use Telemetry.create() instead
+   */
+  constructor(enabled = true) {
+    this.enabled = enabled;
+    this.distinctId = generateInstallationId();
+    this.postHogClient = new PostHogClient(this.enabled);
+  }
+  /**
+   * Set global application context that will be included in all events
+   */
+  setGlobalContext(context) {
+    this.globalContext = { ...context };
+  }
+  /**
+   * Get current global context
+   */
+  getGlobalContext() {
+    return { ...this.globalContext };
+  }
+  track(event, properties = {}) {
+    if (!this.enabled) return;
+    const enrichedProperties = {
+      ...this.globalContext,
+      ...properties,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    logger.debug(`Tracking event: ${event}`);
+    this.postHogClient.capture(this.distinctId, event, enrichedProperties);
+  }
+  /**
+   * Capture exception using PostHog's native error tracking with global context
+   */
+  captureException(error, properties = {}) {
+    if (!this.enabled) return;
+    const enrichedProperties = {
+      ...this.globalContext,
+      ...properties,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    logger.debug(
+      `Capturing exception: ${error instanceof Error ? error.message : String(error)}`
+    );
+    this.postHogClient.captureException(
+      this.distinctId,
+      error instanceof Error ? error : new Error(String(error)),
+      enrichedProperties
+    );
+  }
+  /**
+   * Graceful shutdown with event flushing
+   */
+  async shutdown() {
+    if (!this.enabled) return;
+    await this.postHogClient.shutdown();
+  }
+  /**
+   * Check if telemetry is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+}
+let telemetryInstance = null;
+function getTelemetryInstance() {
+  if (!telemetryInstance) {
+    telemetryInstance = Telemetry.create();
+  }
+  return telemetryInstance;
+}
+function initTelemetry(options) {
+  TelemetryConfig.getInstance().setEnabled(options.enabled);
+  generateInstallationId(options.storePath);
+  telemetryInstance = Telemetry.create();
+}
+const telemetry = new Proxy({}, {
+  get(_target, prop) {
+    const instance = getTelemetryInstance();
+    const value = instance[prop];
+    if (typeof value === "function") {
+      return value.bind(instance);
+    }
+    return value;
+  }
+});
+class TelemetryService {
+  eventBus;
+  unsubscribers = [];
+  constructor(eventBus) {
+    this.eventBus = eventBus;
+    this.setupEventListeners();
+  }
+  /**
+   * Sets up event listeners for pipeline events.
+   */
+  setupEventListeners() {
+    const unsubStatusChange = this.eventBus.on(
+      EventType.JOB_STATUS_CHANGE,
+      this.handleJobStatusChange.bind(this)
+    );
+    const unsubProgress = this.eventBus.on(
+      EventType.JOB_PROGRESS,
+      this.handleJobProgress.bind(this)
+    );
+    this.unsubscribers.push(unsubStatusChange, unsubProgress);
+    logger.debug("TelemetryService initialized and listening to events");
+  }
+  /**
+   * Handles job status change events and tracks them to analytics.
+   * Only tracks events for meaningful state transitions: started, completed, and failed.
+   */
+  handleJobStatusChange(job) {
+    const duration = job.startedAt ? Date.now() - job.startedAt.getTime() : null;
+    const queueWaitTime = job.startedAt && job.createdAt ? job.startedAt.getTime() - job.createdAt.getTime() : null;
+    switch (job.status) {
+      case PipelineJobStatus.RUNNING:
+        telemetry.track(TelemetryEvent.PIPELINE_JOB_STARTED, {
+          jobId: job.id,
+          library: job.library,
+          hasVersion: !!job.version,
+          maxPagesConfigured: job.progressMaxPages || 0,
+          queueWaitTimeMs: queueWaitTime
+        });
+        break;
+      case PipelineJobStatus.COMPLETED:
+        telemetry.track(TelemetryEvent.PIPELINE_JOB_COMPLETED, {
+          jobId: job.id,
+          library: job.library,
+          durationMs: duration,
+          pagesProcessed: job.progressPages || 0,
+          maxPagesConfigured: job.progressMaxPages || 0,
+          hasVersion: !!job.version,
+          throughputPagesPerSecond: duration && job.progressPages ? Math.round(job.progressPages / duration * 1e3) : 0
+        });
+        break;
+      case PipelineJobStatus.FAILED:
+        telemetry.track(TelemetryEvent.PIPELINE_JOB_FAILED, {
+          jobId: job.id,
+          library: job.library,
+          durationMs: duration,
+          pagesProcessed: job.progressPages || 0,
+          maxPagesConfigured: job.progressMaxPages || 0,
+          hasVersion: !!job.version,
+          hasError: !!job.error,
+          errorMessage: job.error?.message
+        });
+        break;
+    }
+  }
+  /**
+   * Handles job progress events. Currently a no-op but can be extended
+   * for progress-specific telemetry tracking.
+   */
+  handleJobProgress(_event) {
+  }
+  /**
+   * Cleans up event listeners.
+   */
+  shutdown() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+    logger.debug("TelemetryService shut down");
+  }
+}
+class EventBusService {
+  emitter;
+  constructor() {
+    this.emitter = new EventEmitter();
+    this.emitter.setMaxListeners(100);
+  }
+  /**
+   * Emit an event to all subscribers.
+   */
+  emit(eventType, payload) {
+    logger.debug(`Event emitted: ${eventType}`);
+    this.emitter.emit(eventType, payload);
+  }
+  /**
+   * Subscribe to events of a specific type.
+   * Returns an unsubscribe function.
+   */
+  on(eventType, listener) {
+    this.emitter.on(eventType, listener);
+    return () => this.emitter.off(eventType, listener);
+  }
+  /**
+   * Subscribe to events once (auto-unsubscribes after first event).
+   */
+  once(eventType, listener) {
+    this.emitter.once(eventType, listener);
+  }
+  /**
+   * Remove a specific listener.
+   */
+  off(eventType, listener) {
+    this.emitter.off(eventType, listener);
+  }
+  /**
+   * Remove all listeners for a specific event type, or all listeners if no type specified.
+   */
+  removeAllListeners(eventType) {
+    if (eventType === void 0) {
+      this.emitter.removeAllListeners();
+    } else {
+      this.emitter.removeAllListeners(eventType);
+    }
+  }
+  /**
+   * Get the count of listeners for a specific event type.
+   */
+  listenerCount(eventType) {
+    return this.emitter.listenerCount(eventType);
+  }
+}
+class EmbeddingConfig {
+  static instance = null;
+  /**
+   * Get the singleton instance of EmbeddingConfig.
+   * Creates the instance if it doesn't exist.
+   */
+  static getInstance() {
+    if (EmbeddingConfig.instance === null) {
+      EmbeddingConfig.instance = new EmbeddingConfig();
+    }
+    return EmbeddingConfig.instance;
+  }
+  /**
+   * Reset the singleton instance (useful for testing).
+   */
+  static resetInstance() {
+    EmbeddingConfig.instance = null;
+  }
+  /**
+   * Known dimensions for common embedding models.
+   * This avoids expensive API calls for dimension detection in telemetry.
+   *
+   * Note: The "openai" provider also supports OpenAI-compatible APIs like:
+   * - Ollama (local models)
+   * - LMStudio (local models)
+   * - Any service implementing OpenAI's embedding API
+   */
+  knownModelDimensions = {
+    // OpenAI models (also works with Ollama, LMStudio, and other OpenAI-compatible APIs)
+    "text-embedding-3-small": 1536,
+    "text-embedding-3-large": 3072,
+    "text-embedding-ada-002": 1536,
+    // Google Vertex AI models
+    "text-embedding-004": 768,
+    "textembedding-gecko@003": 768,
+    "textembedding-gecko@002": 768,
+    "textembedding-gecko@001": 768,
+    // Google Gemini models (with MRL support)
+    "text-embedding-preview-0409": 768,
+    "embedding-001": 768,
+    // AWS Bedrock models
+    // Amazon Titan models
+    "amazon.titan-embed-text-v1": 1536,
+    "amazon.titan-embed-text-v2:0": 1024,
+    "amazon.titan-embed-image-v1": 1024,
+    // Image embedding model
+    // Cohere models
+    "cohere.embed-english-v3": 1024,
+    "cohere.embed-multilingual-v3": 1024,
+    // SageMaker models (hosted on AWS SageMaker)
+    "intfloat/multilingual-e5-large": 1024,
+    // Additional AWS models that might be supported
+    // Note: Some of these might be placeholders - verify dimensions before use
+    // "amazon.nova-embed-multilingual-v1:0": 4096, // Commented out as noted in source
+    // MTEB Leaderboard models (source: https://huggingface.co/spaces/mteb/leaderboard)
+    // Top performing models from Massive Text Embedding Benchmark
+    "sentence-transformers/all-MiniLM-L6-v2": 384,
+    "gemini-embedding-001": 3072,
+    "Qwen/Qwen3-Embedding-8B": 4096,
+    "Qwen/Qwen3-Embedding-4B": 2560,
+    "Qwen/Qwen3-Embedding-0.6B": 1024,
+    "Linq-AI-Research/Linq-Embed-Mistral": 4096,
+    "Alibaba-NLP/gte-Qwen2-7B-instruct": 3584,
+    "intfloat/multilingual-e5-large-instruct": 1024,
+    "Salesforce/SFR-Embedding-Mistral": 4096,
+    "text-multilingual-embedding-002": 768,
+    "GritLM/GritLM-7B": 4096,
+    "GritLM/GritLM-8x7B": 4096,
+    "intfloat/e5-mistral-7b-instruct": 4096,
+    "Cohere/Cohere-embed-multilingual-v3.0": 1024,
+    "Alibaba-NLP/gte-Qwen2-1.5B-instruct": 8960,
+    "Lajavaness/bilingual-embedding-large": 1024,
+    "Salesforce/SFR-Embedding-2_R": 4096,
+    "NovaSearch/stella_en_1.5B_v5": 8960,
+    "NovaSearch/jasper_en_vision_language_v1": 8960,
+    "nvidia/NV-Embed-v2": 4096,
+    "OrdalieTech/Solon-embeddings-large-0.1": 1024,
+    "BAAI/bge-m3": 1024,
+    "HIT-TMG/KaLM-embedding-multilingual-mini-v1": 896,
+    "jinaai/jina-embeddings-v3": 1024,
+    "Alibaba-NLP/gte-multilingual-base": 768,
+    "Lajavaness/bilingual-embedding-base": 768,
+    "HIT-TMG/KaLM-embedding-multilingual-mini-instruct-v1": 896,
+    "nvidia/NV-Embed-v1": 4096,
+    "Cohere/Cohere-embed-multilingual-light-v3.0": 384,
+    "manu/bge-m3-custom-fr": 1024,
+    "Lajavaness/bilingual-embedding-small": 384,
+    "Snowflake/snowflake-arctic-embed-l-v2.0": 1024,
+    "intfloat/multilingual-e5-base": 768,
+    "voyage-3-lite": 512,
+    "voyage-3": 1024,
+    "intfloat/multilingual-e5-small": 384,
+    "Alibaba-NLP/gte-Qwen1.5-7B-instruct": 4096,
+    "Snowflake/snowflake-arctic-embed-m-v2.0": 768,
+    "deepvk/USER-bge-m3": 1024,
+    "Cohere/Cohere-embed-english-v3.0": 1024,
+    "Omartificial-Intelligence-Space/Arabic-labse-Matryoshka": 768,
+    "ibm-granite/granite-embedding-278m-multilingual": 768,
+    "NovaSearch/stella_en_400M_v5": 4096,
+    "omarelshehy/arabic-english-sts-matryoshka": 1024,
+    "sentence-transformers/paraphrase-multilingual-mpnet-base-v2": 768,
+    "Omartificial-Intelligence-Space/Arabic-all-nli-triplet-Matryoshka": 768,
+    "Haon-Chen/speed-embedding-7b-instruct": 4096,
+    "sentence-transformers/LaBSE": 768,
+    "WhereIsAI/UAE-Large-V1": 1024,
+    "ibm-granite/granite-embedding-107m-multilingual": 384,
+    "mixedbread-ai/mxbai-embed-large-v1": 1024,
+    "intfloat/e5-large-v2": 1024,
+    "avsolatorio/GIST-large-Embedding-v0": 1024,
+    "sdadas/mmlw-e5-large": 1024,
+    "nomic-ai/nomic-embed-text-v1": 768,
+    "nomic-ai/nomic-embed-text-v1-ablated": 768,
+    "intfloat/e5-base-v2": 768,
+    "BAAI/bge-large-en-v1.5": 1024,
+    "intfloat/e5-large": 1024,
+    "Omartificial-Intelligence-Space/Arabic-MiniLM-L12-v2-all-nli-triplet": 384,
+    "Cohere/Cohere-embed-english-light-v3.0": 384,
+    "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2": 768,
+    "Gameselo/STS-multilingual-mpnet-base-v2": 768,
+    "thenlper/gte-large": 1024,
+    "avsolatorio/GIST-Embedding-v0": 768,
+    "nomic-ai/nomic-embed-text-v1-unsupervised": 768,
+    "infgrad/stella-base-en-v2": 768,
+    "avsolatorio/NoInstruct-small-Embedding-v0": 384,
+    "dwzhu/e5-base-4k": 768,
+    "sdadas/mmlw-e5-base": 768,
+    "voyage-multilingual-2": 1024,
+    "McGill-NLP/LLM2Vec-Mistral-7B-Instruct-v2-mntp-supervised": 4096,
+    "BAAI/bge-base-en-v1.5": 768,
+    "avsolatorio/GIST-small-Embedding-v0": 384,
+    "sdadas/mmlw-roberta-large": 1024,
+    "nomic-ai/nomic-embed-text-v1.5": 768,
+    "minishlab/potion-multilingual-128M": 256,
+    "shibing624/text2vec-base-multilingual": 384,
+    "thenlper/gte-base": 768,
+    "intfloat/e5-small-v2": 384,
+    "intfloat/e5-base": 768,
+    "sentence-transformers/static-similarity-mrl-multilingual-v1": 1024,
+    "manu/sentence_croissant_alpha_v0.3": 2048,
+    "BAAI/bge-small-en-v1.5": 512,
+    "thenlper/gte-small": 384,
+    "sdadas/mmlw-e5-small": 384,
+    "manu/sentence_croissant_alpha_v0.4": 2048,
+    "manu/sentence_croissant_alpha_v0.2": 2048,
+    "abhinand/MedEmbed-small-v0.1": 384,
+    "ibm-granite/granite-embedding-125m-english": 768,
+    "intfloat/e5-small": 384,
+    "voyage-large-2-instruct": 1024,
+    "sdadas/mmlw-roberta-base": 768,
+    "Snowflake/snowflake-arctic-embed-l": 1024,
+    "Mihaiii/Ivysaur": 384,
+    "Snowflake/snowflake-arctic-embed-m-long": 768,
+    "bigscience/sgpt-bloom-7b1-msmarco": 4096,
+    "avsolatorio/GIST-all-MiniLM-L6-v2": 384,
+    "sergeyzh/LaBSE-ru-turbo": 768,
+    "sentence-transformers/all-mpnet-base-v2": 768,
+    "Snowflake/snowflake-arctic-embed-m": 768,
+    "Snowflake/snowflake-arctic-embed-s": 384,
+    "sentence-transformers/all-MiniLM-L12-v2": 384,
+    "Mihaiii/gte-micro-v4": 384,
+    "Snowflake/snowflake-arctic-embed-m-v1.5": 768,
+    "cointegrated/LaBSE-en-ru": 768,
+    "Mihaiii/Bulbasaur": 384,
+    "ibm-granite/granite-embedding-30m-english": 384,
+    "deepfile/embedder-100p": 768,
+    "Jaume/gemma-2b-embeddings": 2048,
+    "OrlikB/KartonBERT-USE-base-v1": 768,
+    "izhx/udever-bloom-7b1": 4096,
+    "izhx/udever-bloom-1b1": 1024,
+    "brahmairesearch/slx-v0.1": 384,
+    "Mihaiii/Wartortle": 384,
+    "izhx/udever-bloom-3b": 2048,
+    "deepvk/USER-base": 768,
+    "ai-forever/ru-en-RoSBERTa": 1024,
+    "McGill-NLP/LLM2Vec-Mistral-7B-Instruct-v2-mntp-unsup-simcse": 4096,
+    "Mihaiii/Venusaur": 384,
+    "Snowflake/snowflake-arctic-embed-xs": 384,
+    "jinaai/jina-embedding-b-en-v1": 768,
+    "Mihaiii/gte-micro": 384,
+    "aari1995/German_Semantic_STS_V2": 1024,
+    "Mihaiii/Squirtle": 384,
+    "OrlikB/st-polish-kartonberta-base-alpha-v1": 768,
+    "sergeyzh/rubert-tiny-turbo": 312,
+    "minishlab/potion-base-8M": 256,
+    "minishlab/M2V_base_glove_subword": 256,
+    "jinaai/jina-embedding-s-en-v1": 512,
+    "minishlab/potion-base-4M": 128,
+    "minishlab/M2V_base_output": 256,
+    "DeepPavlov/rubert-base-cased-sentence": 768,
+    "jinaai/jina-embeddings-v2-small-en": 512,
+    "cointegrated/rubert-tiny2": 312,
+    "minishlab/M2V_base_glove": 256,
+    "cointegrated/rubert-tiny": 312,
+    "silma-ai/silma-embeddding-matryoshka-v0.1": 768,
+    "DeepPavlov/rubert-base-cased": 768,
+    "Omartificial-Intelligence-Space/Arabic-mpnet-base-all-nli-triplet": 768,
+    "izhx/udever-bloom-560m": 1024,
+    "minishlab/potion-base-2M": 64,
+    "DeepPavlov/distilrubert-small-cased-conversational": 768,
+    "consciousAI/cai-lunaris-text-embeddings": 1024,
+    "deepvk/deberta-v1-base": 768,
+    "Omartificial-Intelligence-Space/Arabert-all-nli-triplet-Matryoshka": 768,
+    "Omartificial-Intelligence-Space/Marbert-all-nli-triplet-Matryoshka": 768,
+    "ai-forever/sbert_large_mt_nlu_ru": 1024,
+    "ai-forever/sbert_large_nlu_ru": 1024,
+    "malenia1/ternary-weight-embedding": 1024,
+    "jinaai/jina-embeddings-v2-base-en": 768,
+    "VPLabs/SearchMap_Preview": 4096,
+    "Hum-Works/lodestone-base-4096-v1": 768,
+    "jinaai/jina-embeddings-v4": 2048
+  };
+  /**
+   * Lowercase lookup map for case-insensitive model dimension queries.
+   * Built lazily from knownModelDimensions to ensure consistency.
+   */
+  modelLookup;
+  constructor() {
+    this.modelLookup = /* @__PURE__ */ new Map();
+    for (const [model, dimensions] of Object.entries(this.knownModelDimensions)) {
+      this.modelLookup.set(model.toLowerCase(), dimensions);
+    }
+  }
+  /**
+   * Parse embedding model configuration from a provided model specification.
+   * This is a synchronous operation that extracts provider, model, and known dimensions.
+   *
+   * Supports various providers:
+   * - openai: OpenAI models and OpenAI-compatible APIs (Ollama, LMStudio, etc.)
+   * - vertex: Google Cloud Vertex AI
+   * - gemini: Google Generative AI
+   * - aws: AWS Bedrock models
+   * - microsoft: Azure OpenAI
+   * - sagemaker: AWS SageMaker hosted models
+   *
+   * @param modelSpec Model specification (e.g., "openai:text-embedding-3-small"), defaults to "text-embedding-3-small"
+   * @returns Parsed embedding model configuration
+   */
+  parse(modelSpec) {
+    const spec = normalizeEnvValue(modelSpec || "text-embedding-3-small");
+    const colonIndex = spec.indexOf(":");
+    let provider;
+    let model;
+    if (colonIndex === -1) {
+      provider = "openai";
+      model = spec;
+    } else {
+      provider = spec.substring(0, colonIndex);
+      model = spec.substring(colonIndex + 1);
+    }
+    const dimensions = this.modelLookup?.get(model.toLowerCase()) || null;
+    return {
+      provider,
+      model,
+      dimensions,
+      modelSpec: spec
+    };
+  }
+  /**
+   * Get the known dimensions for a specific model.
+   * Returns null if the model dimensions are not known.
+   * Uses case-insensitive lookup.
+   *
+   * @param model The model name (e.g., "text-embedding-3-small")
+   * @returns Known dimensions or null
+   */
+  getKnownDimensions(model) {
+    return this.modelLookup?.get(model.toLowerCase()) || null;
+  }
+  /**
+   * Add or update known dimensions for a model.
+   * This can be used to cache discovered dimensions.
+   * Stores both original case and lowercase for consistent lookup.
+   *
+   * @param model The model name
+   * @param dimensions The dimensions to cache
+   */
+  setKnownDimensions(model, dimensions) {
+    this.knownModelDimensions[model] = dimensions;
+    if (this.modelLookup) {
+      this.modelLookup.set(model.toLowerCase(), dimensions);
+    }
+  }
+  /**
+   * Static method to parse embedding model configuration using the singleton instance.
+   * This maintains backward compatibility while using the class-based approach.
+   */
+  static parseEmbeddingConfig(modelSpec) {
+    return EmbeddingConfig.getInstance().parse(modelSpec);
+  }
+  /**
+   * Static method to get known model dimensions using the singleton instance.
+   * This maintains backward compatibility while using the class-based approach.
+   */
+  static getKnownModelDimensions(model) {
+    return EmbeddingConfig.getInstance().getKnownDimensions(model);
+  }
+  /**
+   * Static method to set known model dimensions using the singleton instance.
+   * This maintains backward compatibility while using the class-based approach.
+   */
+  static setKnownModelDimensions(model, dimensions) {
+    EmbeddingConfig.getInstance().setKnownDimensions(model, dimensions);
+  }
+}
+function getEventBus(argv) {
+  const eventBus = argv._eventBus;
+  if (!eventBus) {
+    throw new Error("EventBusService not initialized");
+  }
+  return eventBus;
+}
+function getGlobalOptions(argv) {
+  return argv;
+}
+function ensurePlaywrightBrowsersInstalled() {
+  if (process.env.PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD === "1") {
+    logger.debug(
+      "PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD is set, skipping Playwright browser install."
+    );
+    return;
+  }
+  const chromiumEnvPath = process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH;
+  if (chromiumEnvPath && existsSync(chromiumEnvPath)) {
+    logger.debug(
+      `PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH is set to '${chromiumEnvPath}', skipping Playwright browser install.`
+    );
+    return;
+  }
+  try {
+    const chromiumPath = chromium.executablePath();
+    if (!chromiumPath || !existsSync(chromiumPath)) {
+      throw new Error("Playwright Chromium browser not found");
+    }
+  } catch (error) {
+    logger.debug(String(error));
+    try {
+      logger.info(
+        "🌐 Installing Playwright Chromium browser... (this may take a moment)"
+      );
+      execSync("npm exec -y playwright install --no-shell --with-deps chromium", {
+        stdio: "ignore",
+        // Suppress output
+        cwd: getProjectRoot()
+      });
+    } catch (_installErr) {
+      logger.error(
+        "❌ Failed to install Playwright browsers automatically. Please run:\n  npx playwright install --no-shell --with-deps chromium\nand try again."
+      );
+      process.exit(1);
+    }
+  }
+}
+function resolveProtocol(protocol) {
+  if (protocol === "auto") {
+    if (!process.stdin.isTTY && !process.stdout.isTTY) {
+      return "stdio";
+    }
+    return "http";
+  }
+  if (protocol === "stdio" || protocol === "http") {
+    return protocol;
+  }
+  throw new Error(`Invalid protocol: ${protocol}. Must be 'auto', 'stdio', or 'http'`);
+}
+function validateResumeFlag(resume, serverUrl) {
+  if (resume && serverUrl) {
+    throw new Error(
+      "--resume flag is incompatible with --server-url. External workers handle their own job recovery."
+    );
+  }
+}
+function validatePort(portString) {
+  const port = Number.parseInt(portString, 10);
+  if (Number.isNaN(port) || port < 1 || port > 65535) {
+    throw new Error("Invalid port number");
+  }
+  return port;
+}
+function validateHost(hostString) {
+  const trimmed = hostString.trim();
+  if (!trimmed) {
+    throw new Error("Host cannot be empty");
+  }
+  if (trimmed.includes(" ") || trimmed.includes("	") || trimmed.includes("\n")) {
+    throw new Error("Host cannot contain whitespace");
+  }
+  return trimmed;
+}
+function createAppServerConfig(options) {
+  return {
+    enableWebInterface: options.enableWebInterface ?? false,
+    enableMcpServer: options.enableMcpServer ?? true,
+    enableApiServer: options.enableApiServer ?? false,
+    enableWorker: options.enableWorker ?? true,
+    port: options.port,
+    externalWorkerUrl: options.externalWorkerUrl,
+    showLogo: options.showLogo ?? true,
+    startupContext: options.startupContext
+  };
+}
+function parseHeaders(headerOptions) {
+  const headers = {};
+  if (Array.isArray(headerOptions)) {
+    for (const entry of headerOptions) {
+      const idx = entry.indexOf(":");
+      if (idx > 0) {
+        const name = entry.slice(0, idx).trim();
+        const value = entry.slice(idx + 1).trim();
+        if (name) headers[name] = value;
+      }
+    }
+  }
+  return headers;
+}
+function parseAuthConfig(options) {
+  if (!options.authEnabled) {
+    return void 0;
+  }
+  return {
+    enabled: true,
+    issuerUrl: options.authIssuerUrl,
+    audience: options.authAudience,
+    scopes: ["openid", "profile"]
+    // Default scopes for OAuth2/OIDC
+  };
+}
+function validateAuthConfig(authConfig) {
+  if (!authConfig.enabled) {
+    return;
+  }
+  const errors = [];
+  if (!authConfig.issuerUrl) {
+    errors.push("--auth-issuer-url is required when auth is enabled");
+  } else {
+    try {
+      const url = new URL(authConfig.issuerUrl);
+      if (url.protocol !== "https:") {
+        errors.push("Issuer URL must use HTTPS protocol");
+      }
+    } catch {
+      errors.push("Issuer URL must be a valid URL");
+    }
+  }
+  if (!authConfig.audience) {
+    errors.push("--auth-audience is required when auth is enabled");
+  } else {
+    try {
+      const url = new URL(authConfig.audience);
+      if (url.protocol === "http:" && url.hostname !== "localhost") {
+        logger.warn(
+          "⚠️  Audience uses HTTP protocol - consider using HTTPS for production"
+        );
+      }
+      if (url.hash) {
+        errors.push("Audience must not contain URL fragments");
+      }
+    } catch {
+      if (authConfig.audience.startsWith("urn:")) {
+        const urnParts = authConfig.audience.split(":");
+        if (urnParts.length < 3 || !urnParts[1] || !urnParts[2]) {
+          errors.push("URN audience must follow format: urn:namespace:specific-string");
+        }
+      } else {
+        errors.push(
+          "Audience must be a valid absolute URL or URN (e.g., https://api.example.com or urn:company:service)"
+        );
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`Auth configuration validation failed:
+${errors.join("\n")}`);
+  }
+}
+function warnHttpUsage(authConfig, port) {
+  if (!authConfig?.enabled) {
+    return;
+  }
+  const isLocalhost = process.env.NODE_ENV !== "production" || port === 6280 || // default dev port
+  process.env.HOSTNAME?.includes("localhost");
+  if (!isLocalhost) {
+    logger.warn(
+      "⚠️  Authentication is enabled but running over HTTP in production. Consider using HTTPS for security."
+    );
+  }
+}
+function createEventServices() {
+  const eventBus = new EventBusService();
+  const telemetryService = new TelemetryService(eventBus);
+  return { eventBus, telemetryService };
+}
+function resolveEmbeddingContext(embeddingModel) {
+  try {
+    const modelSpec = embeddingModel;
+    if (!modelSpec) {
+      logger.debug("No embedding model specified. Embeddings are disabled.");
+      return null;
+    }
+    logger.debug(`Resolving embedding configuration for model: ${modelSpec}`);
+    return EmbeddingConfig.parseEmbeddingConfig(modelSpec);
+  } catch (error) {
+    logger.debug(`Failed to resolve embedding configuration: ${error}`);
+    return null;
+  }
+}
+const utils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createAppServerConfig,
+  createEventServices,
+  ensurePlaywrightBrowsersInstalled,
+  getEventBus,
+  getGlobalOptions,
+  parseAuthConfig,
+  parseHeaders,
+  resolveEmbeddingContext,
+  resolveProtocol,
+  validateAuthConfig,
+  validateHost,
+  validatePort,
+  validateResumeFlag,
+  warnHttpUsage
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  EmbeddingConfig as E,
+  PipelineJobStatus as P,
+  ServerEventName as S,
+  TelemetryEvent as T,
+  EventType as a,
+  getEventBus as b,
+  createAppServerConfig as c,
+  parseHeaders as d,
+  ensurePlaywrightBrowsersInstalled as e,
+  validatePort as f,
+  getProjectRoot as g,
+  validateHost as h,
+  resolveStorePath as i,
+  initTelemetry as j,
+  EventBusService as k,
+  TelemetryService as l,
+  parseAuthConfig as p,
+  resolveProtocol as r,
+  shouldEnableTelemetry as s,
+  telemetry as t,
+  utils as u,
+  validateAuthConfig as v,
+  warnHttpUsage as w
+};
+//# sourceMappingURL=utils-XwXdQlZ_.js.map