@coderule/clients 1.2.0 → 1.4.0

package/dist/index.d.ts

@@ -23,6 +23,38 @@ interface JWTPayload {
 }
 declare function decodeJWT(jwtToken: string): JWTPayload | null;
 
+interface JWTProvider {
+    getJWT(forceRefresh?: boolean): Promise<string>;
+}
+interface TokenRefreshInfo {
+    token: string;
+    expiresAt: number;
+    serverUrl?: string;
+}
+interface JWTFactoryOptions {
+    minTtlMs?: number;
+    onTokenRefreshed?: (info: TokenRefreshInfo) => void;
+}
+declare class JWTFactory implements JWTProvider {
+    private readonly authClient;
+    private sourceToken;
+    private cache?;
+    private refreshPromise?;
+    private readonly minTtlMs;
+    private readonly onTokenRefreshed?;
+    private currentServerUrl?;
+    constructor(authClient: AuthHttpClient, sourceToken: string, options?: JWTFactoryOptions);
+    setSourceToken(token: string): void;
+    invalidate(): void;
+    getJWT(forceRefresh?: boolean): Promise<string>;
+    private refresh;
+    private fetchNewToken;
+    private resolveExpiryMs;
+    private extractServerUrl;
+    private emitTokenRefreshed;
+    getServerUrl(): string | undefined;
+}
+
 interface SnapshotStatus$1 {
     status: 'NOT_FOUND' | 'READY' | 'INDEXING' | 'PENDING' | 'FAILED' | 'MISSING_CONTENT';
     snapshot_hash?: string;
@@ -50,17 +82,25 @@ interface HealthResponse$1 {
     version?: string;
     [key: string]: any;
 }
+interface SyncClientConfig {
+    baseUrl?: string;
+    timeout?: number;
+    jwtProvider: JWTProvider;
+}
 declare class SyncHttpClient {
     private baseUrl;
     private timeout;
     private apiBase;
-    constructor(uri?: string, timeout?: number);
-    checkSnapshotStatus(snapshotHash: string, jwt: string): Promise<SnapshotStatus$1>;
-    createSnapshot(snapshotHash: string, files: FileInfo[], jwt: string): Promise<SnapshotStatus$1>;
+    private readonly jwtProvider;
+    constructor({ baseUrl, timeout, jwtProvider, }: SyncClientConfig);
+    updateBaseUrl(baseUrl: string): void;
+    private configureBase;
+    checkSnapshotStatus(snapshotHash: string): Promise<SnapshotStatus$1>;
+    createSnapshot(snapshotHash: string, files: FileInfo[]): Promise<SnapshotStatus$1>;
     uploadFileContent(filesContent: Map<string, {
         path: string;
         content: Buffer | string;
-    }>, jwt: string): Promise<UploadResult>;
+    }>): Promise<UploadResult>;
     static calculateFileHash(filePath: string, content: Buffer | string): string;
     static calculateSnapshotHash(fileHashes: string[]): string;
     health(): Promise<HealthResponse$1>;
@@ -101,17 +141,25 @@ interface CacheStats {
     ttl: number;
     snapshots: string[];
 }
+interface RetrievalClientConfig {
+    baseUrl?: string;
+    timeout?: number;
+    jwtProvider: JWTProvider;
+}
 declare class RetrievalHttpClient {
     private baseUrl;
     private timeout;
     private apiBase;
-    constructor(uri?: string, timeout?: number);
+    private readonly jwtProvider;
+    constructor({ baseUrl, timeout, jwtProvider, }: RetrievalClientConfig);
+    updateBaseUrl(baseUrl: string): void;
+    private configureBase;
     healthCheck(): Promise<HealthResponse>;
-    query(snapshotHash: string, queryText: string, budgetTokens: number | undefined, jwt: string, options?: RetrievalOptions): Promise<RetrievalResult>;
-    checkSnapshotStatus(snapshotHash: string, jwt: string): Promise<SnapshotStatus>;
-    clearCache(jwt: string): Promise<boolean>;
-    getCacheStats(jwt: string): Promise<CacheStats>;
-    queryWithOptions(snapshotHash: string, queryText: string, jwt: string, budgetTokens?: number, flowStrength?: number, blendAlpha?: number, hopDepth?: number, maxIterations?: number, split?: number, formatter?: 'standard' | 'compact'): Promise<RetrievalResult>;
+    query(snapshotHash: string, queryText: string, budgetTokens?: number, options?: RetrievalOptions): Promise<RetrievalResult>;
+    checkSnapshotStatus(snapshotHash: string): Promise<SnapshotStatus>;
+    clearCache(): Promise<boolean>;
+    getCacheStats(): Promise<CacheStats>;
+    queryWithOptions(snapshotHash: string, queryText: string, budgetTokens?: number, flowStrength?: number, blendAlpha?: number, hopDepth?: number, maxIterations?: number, split?: number, formatter?: 'standard' | 'compact'): Promise<RetrievalResult>;
     close(): void;
 }
 
@@ -127,12 +175,20 @@ interface HealthStatus {
     frontends_loaded: number;
     info: Record<string, string>;
 }
+interface ASTClientConfig {
+    baseUrl?: string;
+    timeout?: number;
+    jwtProvider: JWTProvider;
+}
 declare class ASTHttpClient {
     private baseUrl;
     private timeout;
     private apiBase;
-    constructor(uri?: string, timeout?: number);
-    getVisitorRulesV2(jwt: string): Promise<VisitorRulesV2>;
+    private readonly jwtProvider;
+    constructor({ baseUrl, timeout, jwtProvider, }: ASTClientConfig);
+    updateBaseUrl(baseUrl: string): void;
+    private configureBase;
+    getVisitorRulesV2(): Promise<VisitorRulesV2>;
     health(): Promise<HealthStatus>;
     static compileRulesV2(rules: VisitorRulesV2): {
         exts: Set<string>;
@@ -143,6 +199,36 @@ declare class ASTHttpClient {
     close(): void;
 }
 
+type ServiceKey = 'auth' | 'ast' | 'retrieval' | 'sync';
+interface ServiceConfig {
+    baseUrl?: string;
+    timeout?: number;
+}
+interface CoderuleClientOptions {
+    token: string;
+    baseUrl?: string;
+    auth?: ServiceConfig;
+    ast?: ServiceConfig;
+    retrieval?: ServiceConfig;
+    sync?: ServiceConfig;
+    jwtFactory?: JWTFactoryOptions;
+}
+declare class CoderuleClients {
+    readonly auth: AuthHttpClient;
+    readonly ast: ASTHttpClient;
+    readonly retrieval: RetrievalHttpClient;
+    readonly sync: SyncHttpClient;
+    readonly jwtFactory: JWTFactory;
+    private readonly serviceBaseLocked;
+    private lastServerUrl?;
+    constructor(options: CoderuleClientOptions);
+    get jwt(): JWTProvider;
+    getJWT(forceRefresh?: boolean): Promise<string>;
+    setToken(token: string): void;
+    close(): void;
+    private applyServerUrl;
+}
+
 declare const fetch: typeof globalThis.fetch;
 
-export { ASTHttpClient, AuthHttpClient, type HealthStatus, RetrievalHttpClient, SyncHttpClient, type VisitorRulesV2, decodeJWT, fetch };
+export { type ASTClientConfig, ASTHttpClient, AuthHttpClient, type CoderuleClientOptions, CoderuleClients, type HealthStatus, JWTFactory, type JWTFactoryOptions, type JWTProvider, type RetrievalClientConfig, RetrievalHttpClient, type ServiceConfig, type ServiceKey, type SyncClientConfig, SyncHttpClient, type TokenRefreshInfo, type VisitorRulesV2, decodeJWT, fetch };

package/dist/index.js

@@ -237,10 +237,26 @@ init_esm_shims();
 var SyncHttpClient = class {
   /**
    * Initialize the Sync HTTP client
-   * @param uri - URI/URL for connecting to the HTTP server (e.g., "http://localhost:8002")
-   * @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(uri = "http://localhost:8002", timeout = 6e4) {
+  constructor({
+    baseUrl = "http://localhost:8002",
+    timeout = 6e4,
+    jwtProvider
+  }) {
+    if (!jwtProvider) {
+      throw new Error("SyncHttpClient 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}`;
@@ -251,7 +267,6 @@ var SyncHttpClient = class {
     } else {
       this.baseUrl = `${url.protocol}//${url.host}`;
     }
-    this.timeout = timeout;
     if (this.baseUrl.endsWith("/")) {
       this.apiBase = `${this.baseUrl}sync/v1/`;
     } else {
@@ -261,14 +276,14 @@ var SyncHttpClient = class {
   /**
    * Check the status of a snapshot
    * @param snapshotHash - SHA256 hash of the snapshot
-   * @param jwt - JWT token for authorization (required)
    * @returns Snapshot status information
    * @throws Error on HTTP errors or connection errors
    */
-  async checkSnapshotStatus(snapshotHash, jwt) {
-    if (!jwt) {
-      throw new Error("JWT must be provided");
+  async checkSnapshotStatus(snapshotHash) {
+    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();
@@ -306,14 +321,14 @@ var SyncHttpClient = class {
    * Create a new snapshot or get its status if it exists
    * @param snapshotHash - SHA256 hash of the snapshot
    * @param files - List of file information with 'file_path' and 'file_hash'
-   * @param jwt - JWT token for authorization (required)
    * @returns Snapshot creation result or status
    * @throws Error on HTTP errors or connection errors
    */
-  async createSnapshot(snapshotHash, files, jwt) {
-    if (!jwt) {
-      throw new Error("JWT must be provided");
+  async createSnapshot(snapshotHash, files) {
+    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();
@@ -360,14 +375,11 @@ var SyncHttpClient = class {
   /**
    * Upload file content to the service
    * @param filesContent - Map of file_hash to object with 'path' and 'content'
-   * @param jwt - JWT token for authorization (required)
    * @returns Upload result with counts
    * @throws Error on HTTP errors or connection errors
    */
-  async uploadFileContent(filesContent, jwt) {
-    if (!jwt) {
-      throw new Error("JWT must be provided");
-    }
+  async uploadFileContent(filesContent) {
+    const jwt = await this.jwtProvider.getJWT();
     const url = `${this.apiBase}files/content`;
     try {
       const controller = new AbortController2();
@@ -475,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}`;
@@ -489,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
@@ -545,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();
@@ -620,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();
@@ -671,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();
@@ -709,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();
@@ -758,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,
@@ -767,7 +785,7 @@ 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)
@@ -781,10 +799,26 @@ init_esm_shims();
 var ASTHttpClient = class {
   /**
    * Initialize the AST HTTP client
-   * @param uri - URI/URL for connecting to the HTTP server (e.g., "http://localhost:8003")
-   * @param timeout - Request timeout in milliseconds (default: 60000)
+   * @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(uri = "http://localhost:8003", timeout = 6e4) {
+  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}`;
@@ -795,7 +829,6 @@ var ASTHttpClient = class {
     } else {
       this.baseUrl = `${url.protocol}//${url.host}`;
     }
-    this.timeout = timeout;
     if (this.baseUrl.endsWith("/")) {
       this.apiBase = `${this.baseUrl}api/ast/`;
     } else {
@@ -804,14 +837,11 @@ var ASTHttpClient = class {
   }
   /**
    * Get file visitor rules in v2 format optimized for Chokidar v4
-   * @param jwt - JWT token for authorization (required)
    * @returns Visitor rules with format, include_extensions, include_filenames, exclude_dirnames
    * @throws Error on HTTP errors or connection errors
    */
-  async getVisitorRulesV2(jwt) {
-    if (!jwt) {
-      throw new Error("JWT must be provided");
-    }
+  async getVisitorRulesV2() {
+    const jwt = await this.jwtProvider.getJWT();
     const url = `${this.apiBase}visitor-rules`;
     try {
       const controller = new AbortController2();
@@ -921,6 +951,242 @@ var ASTHttpClient = class {
   }
 };
 
-export { ASTHttpClient, 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