@coderule/clients 1.1.0 → 1.4.0

package/dist/index.js

@@ -237,18 +237,41 @@ init_esm_shims();
 var SyncHttpClient = class {
   /**
    * Initialize the Sync HTTP client
-   * @param baseUrl - Base URL of the Sync service (e.g., "http://localhost:8002")
-   * @param jwtToken - JWT token for authentication
-   * @param timeout - Request timeout in milliseconds (default: 60000)
+   * @param config.baseUrl - URI/URL for connecting to the HTTP server (e.g., "http://localhost:8002")
+   * @param config.timeout - Request timeout in milliseconds (default: 60000)
+   * @param config.jwtProvider - Provider for obtaining JWT tokens
    */
-  constructor(baseUrl, jwtToken, timeout = 6e4) {
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.jwtToken = jwtToken;
+  constructor({
+    baseUrl = "http://localhost:8002",
+    timeout = 6e4,
+    jwtProvider
+  }) {
+    if (!jwtProvider) {
+      throw new Error("SyncHttpClient requires a JWT provider");
+    }
     this.timeout = timeout;
-    this.headers = {
-      Authorization: `Bearer ${jwtToken}`,
-      "Content-Type": "application/json"
-    };
+    this.jwtProvider = jwtProvider;
+    this.configureBase(baseUrl);
+  }
+  updateBaseUrl(baseUrl) {
+    this.configureBase(baseUrl);
+  }
+  configureBase(uri) {
+    let processedUri = uri;
+    if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
+      processedUri = `http://${uri}`;
+    }
+    const url = new URL(processedUri);
+    if (url.pathname && url.pathname !== "/") {
+      this.baseUrl = `${url.protocol}//${url.host}${url.pathname}`;
+    } else {
+      this.baseUrl = `${url.protocol}//${url.host}`;
+    }
+    if (this.baseUrl.endsWith("/")) {
+      this.apiBase = `${this.baseUrl}sync/v1/`;
+    } else {
+      this.apiBase = `${this.baseUrl}/sync/v1/`;
+    }
   }
   /**
    * Check the status of a snapshot
@@ -257,13 +280,20 @@ var SyncHttpClient = class {
    * @throws Error on HTTP errors or connection errors
    */
   async checkSnapshotStatus(snapshotHash) {
-    const url = `${this.baseUrl}/sync/v1/snapshots`;
+    if (!snapshotHash) {
+      throw new Error("Snapshot hash must be provided");
+    }
+    const jwt = await this.jwtProvider.getJWT();
+    const url = `${this.apiBase}snapshots`;
     try {
       const controller = new AbortController2();
       const timeoutId = setTimeout(() => controller.abort(), this.timeout);
       const response = await fetch_wrapper_default(url, {
         method: "POST",
-        headers: this.headers,
+        headers: {
+          Authorization: `Bearer ${jwt}`,
+          "Content-Type": "application/json"
+        },
         body: JSON.stringify({ snapshot_hash: snapshotHash }),
         signal: controller.signal
       });
@@ -295,13 +325,20 @@ var SyncHttpClient = class {
    * @throws Error on HTTP errors or connection errors
    */
   async createSnapshot(snapshotHash, files) {
-    const url = `${this.baseUrl}/sync/v1/snapshots`;
+    if (!snapshotHash) {
+      throw new Error("Snapshot hash must be provided");
+    }
+    const jwt = await this.jwtProvider.getJWT();
+    const url = `${this.apiBase}snapshots`;
     try {
       const controller = new AbortController2();
       const timeoutId = setTimeout(() => controller.abort(), this.timeout);
       const response = await fetch_wrapper_default(url, {
         method: "POST",
-        headers: this.headers,
+        headers: {
+          Authorization: `Bearer ${jwt}`,
+          "Content-Type": "application/json"
+        },
         body: JSON.stringify({
           snapshot_hash: snapshotHash,
           files
@@ -342,7 +379,8 @@ var SyncHttpClient = class {
    * @throws Error on HTTP errors or connection errors
    */
   async uploadFileContent(filesContent) {
-    const url = `${this.baseUrl}/sync/v1/files/content`;
+    const jwt = await this.jwtProvider.getJWT();
+    const url = `${this.apiBase}files/content`;
     try {
       const controller = new AbortController2();
       const timeoutId = setTimeout(() => controller.abort(), this.timeout);
@@ -352,8 +390,9 @@ var SyncHttpClient = class {
         const blob = new Blob([content], { type: "application/octet-stream" });
         formData.append(fileHash, blob, fileData.path);
       }
-      const uploadHeaders = { ...this.headers };
-      delete uploadHeaders["Content-Type"];
+      const uploadHeaders = {
+        Authorization: `Bearer ${jwt}`
+      };
       const response = await fetch_wrapper_default(url, {
         method: "POST",
         headers: uploadHeaders,
@@ -410,13 +449,13 @@ var SyncHttpClient = class {
    * @throws Error on HTTP errors or connection errors
    */
   async health() {
-    const url = `${this.baseUrl}/sync/v1/health`;
+    const url = `${this.apiBase}health`;
     try {
       const controller = new AbortController2();
       const timeoutId = setTimeout(() => controller.abort(), this.timeout);
       const response = await fetch_wrapper_default(url, {
         method: "GET",
-        headers: { Authorization: `Bearer ${this.jwtToken}` },
+        // No authentication required for health check
         signal: controller.signal
       });
       clearTimeout(timeoutId);
@@ -448,10 +487,28 @@ init_esm_shims();
 var RetrievalHttpClient = class {
   /**
    * Initialize the Retrieval HTTP client
-   * @param uri - URI/URL for connecting to the HTTP server (e.g., "http://localhost:8004")
-   * @param timeout - Request timeout in milliseconds (default: 60000)
+   * @param config.baseUrl - URI/URL for connecting to the HTTP server (e.g., "http://localhost:8004")
+   * @param config.timeout - Request timeout in milliseconds (default: 60000)
+   * @param config.jwtProvider - Provider for obtaining JWT tokens
    */
-  constructor(uri = "http://localhost:8004", timeout = 6e4) {
+  constructor({
+    baseUrl = "http://localhost:8004",
+    timeout = 6e4,
+    jwtProvider
+  }) {
+    if (!jwtProvider) {
+      throw new Error("RetrievalHttpClient requires a JWT provider");
+    }
+    this.timeout = timeout;
+    this.jwtProvider = jwtProvider;
+    this.configureBase(baseUrl);
+    console.debug(`Initialized HTTP client for ${this.baseUrl}`);
+    console.debug(`API base: ${this.apiBase}`);
+  }
+  updateBaseUrl(baseUrl) {
+    this.configureBase(baseUrl);
+  }
+  configureBase(uri) {
     let processedUri = uri;
     if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
       processedUri = `http://${uri}`;
@@ -462,14 +519,11 @@ var RetrievalHttpClient = class {
     } else {
       this.baseUrl = `${url.protocol}//${url.host}`;
     }
-    this.timeout = timeout;
     if (this.baseUrl.endsWith("/")) {
       this.apiBase = `${this.baseUrl}api/retrieval/`;
     } else {
       this.apiBase = `${this.baseUrl}/api/retrieval/`;
     }
-    console.debug(`Initialized HTTP client for ${this.baseUrl}`);
-    console.debug(`API base: ${this.apiBase}`);
   }
   /**
    * Check the health status of the Retrieval service
@@ -518,25 +572,22 @@ var RetrievalHttpClient = class {
    * @param snapshotHash - SHA256 hash of the codebase snapshot
    * @param queryText - Natural language query for retrieval
    * @param budgetTokens - Maximum token budget for results (default: 3000)
-   * @param jwt - JWT token for authorization (required)
    * @param options - Optional retrieval parameters
    * @returns Retrieval results with formatted output
    * @throws Error on query failures
    */
-  async query(snapshotHash, queryText, budgetTokens = 3e3, jwt, options) {
+  async query(snapshotHash, queryText, budgetTokens = 3e3, options) {
     if (!snapshotHash) {
       throw new Error("Snapshot hash must be provided");
     }
     if (!queryText) {
       throw new Error("Query text must be provided");
     }
-    if (!jwt) {
-      throw new Error("JWT must be provided");
-    }
     if (budgetTokens < 100) {
       throw new Error("Budget tokens must be at least 100");
     }
     const startTime = Date.now();
+    const jwt = await this.jwtProvider.getJWT();
     const queryEndpoint = `${this.apiBase}query`;
     try {
       const controller = new AbortController2();
@@ -593,13 +644,11 @@ var RetrievalHttpClient = class {
    * @returns Snapshot status information
    * @throws Error on status check failures
    */
-  async checkSnapshotStatus(snapshotHash, jwt) {
+  async checkSnapshotStatus(snapshotHash) {
     if (!snapshotHash) {
       throw new Error("Snapshot hash must be provided");
     }
-    if (!jwt) {
-      throw new Error("JWT must be provided");
-    }
+    const jwt = await this.jwtProvider.getJWT();
     const statusEndpoint = `${this.apiBase}snapshots/${snapshotHash}/status`;
     try {
       const controller = new AbortController2();
@@ -644,10 +693,8 @@ var RetrievalHttpClient = class {
    * @returns true if cache cleared successfully
    * @throws Error on cache clear failures
    */
-  async clearCache(jwt) {
-    if (!jwt) {
-      throw new Error("JWT must be provided");
-    }
+  async clearCache() {
+    const jwt = await this.jwtProvider.getJWT();
     const cacheEndpoint = `${this.apiBase}cache`;
     try {
       const controller = new AbortController2();
@@ -682,10 +729,8 @@ var RetrievalHttpClient = class {
    * @returns Cache statistics
    * @throws Error on stats retrieval failures
    */
-  async getCacheStats(jwt) {
-    if (!jwt) {
-      throw new Error("JWT must be provided");
-    }
+  async getCacheStats() {
+    const jwt = await this.jwtProvider.getJWT();
     const statsEndpoint = `${this.apiBase}cache/stats`;
     try {
       const controller = new AbortController2();
@@ -731,7 +776,7 @@ var RetrievalHttpClient = class {
    * @param formatter - Output format "standard" or "compact"
    * @returns Retrieval results
    */
-  async queryWithOptions(snapshotHash, queryText, jwt, budgetTokens = 3e3, flowStrength = 1.5, blendAlpha = 0.8, hopDepth = 2, maxIterations = 12, split = 0.8, formatter = "standard") {
+  async queryWithOptions(snapshotHash, queryText, budgetTokens = 3e3, flowStrength = 1.5, blendAlpha = 0.8, hopDepth = 2, maxIterations = 12, split = 0.8, formatter = "standard") {
     const options = {
       flow_strength: flowStrength,
       blend_alpha: blendAlpha,
@@ -740,7 +785,164 @@ var RetrievalHttpClient = class {
       split,
       formatter
     };
-    return this.query(snapshotHash, queryText, budgetTokens, jwt, options);
+    return this.query(snapshotHash, queryText, budgetTokens, options);
+  }
+  /**
+   * Close the HTTP client connection (no-op for fetch)
+   */
+  close() {
+  }
+};
+
+// src/clients/ast-client.ts
+init_esm_shims();
+var ASTHttpClient = class {
+  /**
+   * Initialize the AST HTTP client
+   * @param config.baseUrl - URI/URL for connecting to the HTTP server (e.g., "http://localhost:8003")
+   * @param config.timeout - Request timeout in milliseconds (default: 60000)
+   * @param config.jwtProvider - Provider for obtaining JWT tokens
+   */
+  constructor({
+    baseUrl = "http://localhost:8003",
+    timeout = 6e4,
+    jwtProvider
+  }) {
+    if (!jwtProvider) {
+      throw new Error("ASTHttpClient requires a JWT provider");
+    }
+    this.timeout = timeout;
+    this.jwtProvider = jwtProvider;
+    this.configureBase(baseUrl);
+  }
+  updateBaseUrl(baseUrl) {
+    this.configureBase(baseUrl);
+  }
+  configureBase(uri) {
+    let processedUri = uri;
+    if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
+      processedUri = `http://${uri}`;
+    }
+    const url = new URL(processedUri);
+    if (url.pathname && url.pathname !== "/") {
+      this.baseUrl = `${url.protocol}//${url.host}${url.pathname}`;
+    } else {
+      this.baseUrl = `${url.protocol}//${url.host}`;
+    }
+    if (this.baseUrl.endsWith("/")) {
+      this.apiBase = `${this.baseUrl}api/ast/`;
+    } else {
+      this.apiBase = `${this.baseUrl}/api/ast/`;
+    }
+  }
+  /**
+   * Get file visitor rules in v2 format optimized for Chokidar v4
+   * @returns Visitor rules with format, include_extensions, include_filenames, exclude_dirnames
+   * @throws Error on HTTP errors or connection errors
+   */
+  async getVisitorRulesV2() {
+    const jwt = await this.jwtProvider.getJWT();
+    const url = `${this.apiBase}visitor-rules`;
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch_wrapper_default(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${jwt}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Failed to get visitor rules v2 with status ${response.status}: ${errorText}`
+        );
+      }
+      const data = await response.json();
+      if (data.format !== "segments+exts@v2") {
+        throw new Error(`Unexpected visitor rules format: ${data.format}`);
+      }
+      return data;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Failed to get visitor rules v2: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * Check the health status of the AST service
+   * @returns Health status information
+   * @throws Error on HTTP errors or connection errors
+   */
+  async health() {
+    const url = `${this.apiBase}health`;
+    try {
+      const controller = new AbortController2();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch_wrapper_default(url, {
+        method: "GET",
+        // No authentication required for health check
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Health check failed with status ${response.status}: ${errorText}`
+        );
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.timeout}ms`);
+      }
+      console.error(`Health check failed: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * Compile visitor rules v2 for use with Chokidar v4
+   * This is a helper method that compiles the rules into a format
+   * that can be directly used with Chokidar's ignored option
+   * @param rules - The visitor rules v2 from the server
+   * @returns Compiled rules with Sets and RegExp for efficient matching
+   */
+  static compileRulesV2(rules) {
+    if (rules.format !== "segments+exts@v2") {
+      throw new Error(`Unsupported rules format: ${rules.format}`);
+    }
+    const exts = new Set(rules.include_extensions.map((e) => e.toLowerCase()));
+    const names = new Set(rules.include_filenames.map((n) => n.toLowerCase()));
+    const dirs = new Set(rules.exclude_dirnames.map((n) => n.toLowerCase()));
+    const escapeRe = (s) => s.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+    const dirRe = new RegExp(
+      `(?:^|[\\/])(?:${[...dirs].map(escapeRe).join("|")})(?:[\\/]|$)`,
+      "i"
+    );
+    return { exts, names, dirRe };
+  }
+  /**
+   * Build Chokidar v4 `ignored` predicate from compiled rules
+   * @param compiled - Compiled rules from compileRulesV2
+   * @returns Predicate function that returns true to ignore, false to watch
+   */
+  static buildIgnoredPredicate(compiled) {
+    return (p, stats) => {
+      const posix = p.replace(/\\/g, "/");
+      if (compiled.dirRe.test(posix)) return true;
+      if (stats?.isDirectory?.()) return false;
+      const base = posix.split("/").pop()?.toLowerCase() || "";
+      if (compiled.names.has(base)) return false;
+      const extIndex = base.lastIndexOf(".");
+      const ext = extIndex > -1 ? base.slice(extIndex).toLowerCase() : "";
+      if (!compiled.exts.has(ext)) return true;
+      return false;
+    };
   }
   /**
    * Close the HTTP client connection (no-op for fetch)
@@ -749,6 +951,242 @@ var RetrievalHttpClient = class {
   }
 };
 
-export { AuthHttpClient, RetrievalHttpClient, SyncHttpClient, decodeJWT, fetch_wrapper_default as fetch };
+// src/utils/jwt-factory.ts
+init_esm_shims();
+var DEFAULT_MIN_TTL_MS = 5e3;
+var JWTFactory = class {
+  constructor(authClient, sourceToken, options = {}) {
+    this.authClient = authClient;
+    this.sourceToken = sourceToken;
+    if (!sourceToken) {
+      throw new Error("JWTFactory requires a non-empty source token");
+    }
+    this.minTtlMs = options.minTtlMs ?? DEFAULT_MIN_TTL_MS;
+    this.onTokenRefreshed = options.onTokenRefreshed;
+  }
+  setSourceToken(token) {
+    if (!token) {
+      throw new Error("JWTFactory requires a non-empty source token");
+    }
+    if (token !== this.sourceToken) {
+      this.sourceToken = token;
+      this.cache = void 0;
+      this.currentServerUrl = void 0;
+    }
+  }
+  invalidate() {
+    this.cache = void 0;
+    this.currentServerUrl = void 0;
+  }
+  async getJWT(forceRefresh = false) {
+    const now = Date.now();
+    if (!forceRefresh && this.cache) {
+      if (now < this.cache.expiresAt) {
+        if (now < this.cache.refreshAt) {
+          return this.cache.token;
+        }
+      } else {
+        this.cache = void 0;
+      }
+    }
+    return this.refresh(now, forceRefresh);
+  }
+  async refresh(now, forceRefresh) {
+    if (!this.refreshPromise) {
+      this.refreshPromise = this.fetchNewToken().finally(() => {
+        this.refreshPromise = void 0;
+      });
+    }
+    try {
+      return await this.refreshPromise;
+    } catch (error) {
+      if (!forceRefresh && this.cache && now < this.cache.expiresAt) {
+        console.warn(
+          "Failed to refresh JWT, using cached token until expiry. Reason:",
+          error
+        );
+        return this.cache.token;
+      }
+      throw error;
+    }
+  }
+  async fetchNewToken() {
+    const response = await this.authClient.authenticate(this.sourceToken);
+    const fetchedAt = Date.now();
+    const expiresAt = this.resolveExpiryMs(
+      response.jwt,
+      response.expires_at,
+      fetchedAt
+    );
+    const payload = decodeJWT(response.jwt);
+    const serverUrl = this.extractServerUrl(payload);
+    const halfLife = Math.max((expiresAt - fetchedAt) / 2, this.minTtlMs);
+    const refreshAt = fetchedAt + halfLife;
+    this.cache = {
+      token: response.jwt,
+      expiresAt,
+      refreshAt,
+      fetchedAt,
+      serverUrl
+    };
+    this.currentServerUrl = serverUrl;
+    this.emitTokenRefreshed({
+      token: response.jwt,
+      expiresAt,
+      serverUrl
+    });
+    return response.jwt;
+  }
+  resolveExpiryMs(jwt, expiresAt, referenceTime) {
+    if (expiresAt) {
+      const parsed = Date.parse(expiresAt);
+      if (!Number.isNaN(parsed) && parsed > referenceTime + this.minTtlMs) {
+        return parsed;
+      }
+    }
+    const decoded = decodeJWT(jwt);
+    if (decoded?.exp) {
+      const expMs = decoded.exp * 1e3;
+      if (expMs > referenceTime + this.minTtlMs) {
+        return expMs;
+      }
+    }
+    return referenceTime + Math.max(this.minTtlMs, 6e4);
+  }
+  extractServerUrl(payload) {
+    const possibleUrl = payload?.server_url;
+    if (typeof possibleUrl === "string" && possibleUrl.trim()) {
+      return possibleUrl.trim();
+    }
+    return void 0;
+  }
+  emitTokenRefreshed(info) {
+    if (this.onTokenRefreshed) {
+      try {
+        this.onTokenRefreshed(info);
+      } catch (error) {
+        console.warn("JWTFactory onTokenRefreshed callback failed:", error);
+      }
+    }
+  }
+  getServerUrl() {
+    return this.currentServerUrl ?? this.cache?.serverUrl;
+  }
+};
+
+// src/coderule-clients.ts
+init_esm_shims();
+var DEFAULT_AUTH_BASE_URL = "https://r.coderule.ai:16803";
+var DEFAULT_SERVICE_BASE_URL = "https://s1.coderule.ai:16803";
+var DEFAULT_TIMEOUTS = {
+  auth: 3e4,
+  ast: 6e4,
+  retrieval: 6e4,
+  sync: 6e4
+};
+function resolveOverrides(options) {
+  return {
+    auth: options.auth,
+    ast: options.ast,
+    retrieval: options.retrieval,
+    sync: options.sync
+  };
+}
+function resolveTimeout(service, overrides) {
+  return overrides[service]?.timeout ?? DEFAULT_TIMEOUTS[service];
+}
+var CoderuleClients = class {
+  constructor(options) {
+    if (!options?.token) {
+      throw new Error("CoderuleClients requires a non-empty token");
+    }
+    const overrides = resolveOverrides(options);
+    const baseUrl = options.baseUrl;
+    const authBase = overrides.auth?.baseUrl ?? baseUrl ?? DEFAULT_AUTH_BASE_URL;
+    const authTimeout = resolveTimeout("auth", overrides);
+    this.auth = new AuthHttpClient(authBase, authTimeout);
+    const userTokenCallback = options.jwtFactory?.onTokenRefreshed;
+    const jwtOptions = {
+      ...options.jwtFactory,
+      onTokenRefreshed: (info) => {
+        userTokenCallback?.(info);
+        if (info.serverUrl) {
+          this.applyServerUrl(info.serverUrl);
+        }
+      }
+    };
+    this.jwtFactory = new JWTFactory(this.auth, options.token, jwtOptions);
+    this.serviceBaseLocked = {
+      ast: Boolean(overrides.ast?.baseUrl),
+      retrieval: Boolean(overrides.retrieval?.baseUrl),
+      sync: Boolean(overrides.sync?.baseUrl)
+    };
+    const defaultServiceBase = baseUrl ?? DEFAULT_SERVICE_BASE_URL;
+    this.ast = new ASTHttpClient({
+      baseUrl: overrides.ast?.baseUrl ?? defaultServiceBase,
+      timeout: resolveTimeout("ast", overrides),
+      jwtProvider: this.jwtFactory
+    });
+    this.retrieval = new RetrievalHttpClient({
+      baseUrl: overrides.retrieval?.baseUrl ?? defaultServiceBase,
+      timeout: resolveTimeout("retrieval", overrides),
+      jwtProvider: this.jwtFactory
+    });
+    this.sync = new SyncHttpClient({
+      baseUrl: overrides.sync?.baseUrl ?? defaultServiceBase,
+      timeout: resolveTimeout("sync", overrides),
+      jwtProvider: this.jwtFactory
+    });
+    const initialServerUrl = this.jwtFactory.getServerUrl();
+    if (initialServerUrl) {
+      this.applyServerUrl(initialServerUrl);
+    }
+  }
+  get jwt() {
+    return this.jwtFactory;
+  }
+  async getJWT(forceRefresh = false) {
+    return this.jwtFactory.getJWT(forceRefresh);
+  }
+  setToken(token) {
+    this.jwtFactory.setSourceToken(token);
+  }
+  close() {
+    this.ast.close();
+    this.retrieval.close();
+    this.sync.close();
+    this.auth.close();
+  }
+  applyServerUrl(serverUrl) {
+    const trimmed = serverUrl.trim();
+    if (!trimmed || this.lastServerUrl === trimmed) {
+      return;
+    }
+    this.lastServerUrl = trimmed;
+    try {
+      if (!this.serviceBaseLocked.ast) {
+        this.ast.updateBaseUrl(trimmed);
+      }
+    } catch (error) {
+      console.warn("Failed to update AST client base URL:", error);
+    }
+    try {
+      if (!this.serviceBaseLocked.retrieval) {
+        this.retrieval.updateBaseUrl(trimmed);
+      }
+    } catch (error) {
+      console.warn("Failed to update Retrieval client base URL:", error);
+    }
+    try {
+      if (!this.serviceBaseLocked.sync) {
+        this.sync.updateBaseUrl(trimmed);
+      }
+    } catch (error) {
+      console.warn("Failed to update Sync client base URL:", error);
+    }
+  }
+};
+
+export { ASTHttpClient, AuthHttpClient, CoderuleClients, JWTFactory, RetrievalHttpClient, SyncHttpClient, decodeJWT, fetch_wrapper_default as fetch };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map