@coderule/clients 1.2.0 → 1.5.0

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();
@@ -894,7 +924,7 @@ var ASTHttpClient = class {
       `(?:^|[\\/])(?:${[...dirs].map(escapeRe).join("|")})(?:[\\/]|$)`,
       "i"
     );
-    return { exts, names, dirRe };
+    return { exts, names, dirRe, dirs };
   }
   /**
    * Build Chokidar v4 `ignored` predicate from compiled rules
@@ -904,8 +934,19 @@ var ASTHttpClient = class {
   static buildIgnoredPredicate(compiled) {
     return (p, stats) => {
       const posix = p.replace(/\\/g, "/");
-      if (compiled.dirRe.test(posix)) return true;
-      if (stats?.isDirectory?.()) return false;
+      const parts = posix.split("/").map((segment) => segment.toLowerCase());
+      const isDirectory = stats?.isDirectory?.() ?? false;
+      if (isDirectory) {
+        const current = parts[parts.length - 1];
+        if (compiled.dirs.has(current)) {
+          return true;
+        }
+        return false;
+      }
+      const parentDirs = parts.slice(0, -1);
+      if (parentDirs.some((segment) => compiled.dirs.has(segment))) {
+        return true;
+      }
       const base = posix.split("/").pop()?.toLowerCase() || "";
       if (compiled.names.has(base)) return false;
       const extIndex = base.lastIndexOf(".");
@@ -921,6 +962,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