@juspay/neurolink 9.54.6 → 9.54.8

package/dist/auth/sessionManager.js

@@ -1,6 +1,8 @@
 // src/lib/auth/sessionManager.ts
 import { withTimeout } from "../utils/async/withTimeout.js";
 import { logger } from "../utils/logger.js";
+import { withSpan } from "../telemetry/withSpan.js";
+import { tracers } from "../telemetry/tracers.js";
 /** Mask an identifier for safe logging: show first 4 chars + "***" */
 function maskId(id) {
     if (id.length <= 4) {
@@ -333,6 +335,16 @@ export class SessionManager {
      * Create a new session
      */
     async createSession(user, metadata) {
+        return withSpan({
+            name: "neurolink.auth.session.create",
+            tracer: tracers.auth,
+            attributes: {
+                "auth.user_id": maskId(user.id),
+                "auth.storage": this.config.storage ?? "memory",
+            },
+        }, async () => this._createSession(user, metadata));
+    }
+    async _createSession(user, metadata) {
         const sessionId = crypto.randomUUID();
         const now = new Date();
         const duration = this.config.duration || 3600;
@@ -356,6 +368,20 @@ export class SessionManager {
      * Optionally auto-refreshes if close to expiration.
      */
     async getSession(sessionId, autoRefresh = this.config.autoRefresh) {
+        return withSpan({
+            name: "neurolink.auth.session.get",
+            tracer: tracers.auth,
+            attributes: {
+                "auth.session_id": maskId(sessionId),
+                "auth.auto_refresh": autoRefresh ?? false,
+            },
+        }, async (span) => {
+            const result = await this._getSession(sessionId, autoRefresh);
+            span.setAttribute("auth.found", result !== null);
+            return result;
+        });
+    }
+    async _getSession(sessionId, autoRefresh = this.config.autoRefresh) {
         const session = await this.storage.get(sessionId);
         if (!session) {
             return null;
@@ -381,15 +407,23 @@ export class SessionManager {
      * Refresh a session
      */
     async refreshSession(sessionId) {
-        const session = await this.storage.get(sessionId);
-        if (!session) {
-            return null;
-        }
-        const duration = this.config.duration || 3600;
-        session.expiresAt = new Date(Date.now() + duration * 1000);
-        await this.storage.set(session);
-        logger.debug(`Session refreshed: ${maskId(sessionId)}`);
-        return session;
+        return withSpan({
+            name: "neurolink.auth.session.refresh",
+            tracer: tracers.auth,
+            attributes: { "auth.session_id": maskId(sessionId) },
+        }, async (span) => {
+            const session = await this.storage.get(sessionId);
+            if (!session) {
+                span.setAttribute("auth.found", false);
+                return null;
+            }
+            const duration = this.config.duration || 3600;
+            session.expiresAt = new Date(Date.now() + duration * 1000);
+            await this.storage.set(session);
+            span.setAttribute("auth.found", true);
+            logger.debug(`Session refreshed: ${maskId(sessionId)}`);
+            return session;
+        });
     }
     /**
      * Destroy a session
@@ -415,8 +449,16 @@ export class SessionManager {
      * Validate a session is still active
      */
     async validateSession(sessionId) {
-        const session = await this.storage.get(sessionId);
-        return session !== null && session.isValid;
+        return withSpan({
+            name: "neurolink.auth.session.validate",
+            tracer: tracers.auth,
+            attributes: { "auth.session_id": maskId(sessionId) },
+        }, async (span) => {
+            const session = await this.storage.get(sessionId);
+            const valid = session !== null && session.isValid;
+            span.setAttribute("auth.valid", valid);
+            return valid;
+        });
     }
     /**
      * Update session metadata

package/dist/auth/tokenStore.d.ts

@@ -107,6 +107,7 @@ export declare class TokenStore {
      * @throws TokenStoreError if deletion fails
      */
     clearTokens(provider: string): Promise<void>;
+    private _clearTokensImpl;
     /**
      * Checks if the given tokens are expired
      *
@@ -126,6 +127,7 @@ export declare class TokenStore {
      * @throws TokenStoreError if refresh fails
      */
     getValidToken(provider: string): Promise<string | null>;
+    private _getValidTokenImpl;
     /**
      * Sets the token refresher function for a provider
      *

package/dist/auth/tokenStore.js

@@ -19,6 +19,8 @@ import { createHash } from "crypto";
 import { logger } from "../utils/logger.js";
 import { TokenStoreError } from "../types/index.js";
 import { AsyncMutex } from "../utils/asyncMutex.js";
+import { withSpan } from "../telemetry/withSpan.js";
+import { tracers } from "../telemetry/tracers.js";
 const { readFile, writeFile, mkdir, unlink, access, chmod, rename } = fs;
 // =============================================================================
 // TOKEN STORE CLASS
@@ -106,9 +108,17 @@ export class TokenStore {
      * @throws TokenStoreError if storage fails
      */
     async saveTokens(provider, tokens) {
-        return this._mutex.runExclusive(async () => {
+        return withSpan({
+            name: "neurolink.auth.token.save",
+            tracer: tracers.auth,
+            attributes: {
+                "auth.provider": provider,
+                "auth.has_refresh_token": Boolean(tokens.refreshToken),
+                "auth.token_type": tokens.tokenType,
+            },
+        }, async () => this._mutex.runExclusive(async () => {
             await this._saveTokensInternal(provider, tokens);
-        });
+        }));
     }
     /**
      * Internal save without mutex — callers must already hold the mutex.
@@ -178,8 +188,19 @@ export class TokenStore {
      * @throws TokenStoreError if reading fails (other than file not found)
      */
     async loadTokens(provider) {
-        return this._mutex.runExclusive(async () => {
-            return this._loadTokensInternal(provider);
+        return withSpan({
+            name: "neurolink.auth.token.load",
+            tracer: tracers.auth,
+            attributes: { "auth.provider": provider },
+        }, async (span) => {
+            const result = await this._mutex.runExclusive(async () => {
+                return this._loadTokensInternal(provider);
+            });
+            span.setAttribute("auth.found", result !== null);
+            if (result) {
+                span.setAttribute("auth.expired", this.isTokenExpired(result, 0));
+            }
+            return result;
         });
     }
     /**
@@ -217,6 +238,13 @@ export class TokenStore {
      * @throws TokenStoreError if deletion fails
      */
     async clearTokens(provider) {
+        return withSpan({
+            name: "neurolink.auth.token.clear",
+            tracer: tracers.auth,
+            attributes: { "auth.provider": provider },
+        }, async () => this._clearTokensImpl(provider));
+    }
+    async _clearTokensImpl(provider) {
         return this._mutex.runExclusive(async () => {
             // Clear in-memory refresh state so re-adding an account starts fresh
             this.inFlightRefreshes.delete(provider);
@@ -274,6 +302,13 @@ export class TokenStore {
      * @throws TokenStoreError if refresh fails
      */
     async getValidToken(provider) {
+        return withSpan({
+            name: "neurolink.auth.token.get_valid",
+            tracer: tracers.auth,
+            attributes: { "auth.provider": provider },
+        }, async (span) => this._getValidTokenImpl(provider, span));
+    }
+    async _getValidTokenImpl(provider, span) {
         // Phase 1: Read token under mutex (fast)
         const snapshot = await this._mutex.runExclusive(async () => {
             const tokens = await this._loadTokensInternal(provider);
@@ -283,13 +318,18 @@ export class TokenStore {
             return { ...tokens };
         });
         if (!snapshot) {
+            span.setAttribute("auth.found", false);
             logger.debug("No tokens found for provider", { provider });
             return null;
         }
+        span.setAttribute("auth.found", true);
         // Token is still valid — return immediately
         if (!this.isTokenExpired(snapshot)) {
+            span.setAttribute("auth.refreshed", false);
+            span.setAttribute("auth.expired", false);
             return snapshot.accessToken;
         }
+        span.setAttribute("auth.expired", true);
         logger.debug("Token expired or expiring soon", {
             provider,
             expiresAt: new Date(snapshot.expiresAt).toISOString(),
@@ -368,6 +408,7 @@ export class TokenStore {
         this.inFlightRefreshes.set(provider, refreshPromise);
         try {
             const newTokens = await refreshPromise;
+            span.setAttribute("auth.refreshed", true);
             return newTokens.accessToken;
         }
         finally {

package/dist/autoresearch/tools.d.ts

@@ -7,21 +7,7 @@
  *
  * @module autoresearch/tools
  */
-import type { ExperimentRecord, ResearchConfig } from "../types/index.js";
-import type { RepoPolicy } from "./repoPolicy.js";
-import type { ResultRecorder } from "./resultRecorder.js";
-import type { ExperimentRunner } from "./runner.js";
-import type { ResearchStateStore } from "./stateStore.js";
-/**
- * Dependencies required to create research tools.
- */
-type ResearchToolsDeps = {
-    config: ResearchConfig;
-    stateStore: ResearchStateStore;
-    repoPolicy: RepoPolicy;
-    runner: ExperimentRunner;
-    recorder: ResultRecorder;
-};
+import type { ExperimentRecord, ResearchToolsDeps } from "../types/index.js";
 /**
  * Create research management tools bound to a research session.
  *
@@ -251,4 +237,3 @@ export declare function createResearchTools(deps: ResearchToolsDeps): {
         error?: undefined;
     }>;
 };
-export {};