@serviceme/devtools-core 0.3.2 → 0.3.4

package/dist/auth.js

@@ -181,6 +181,18 @@ var AccessControl = class {
   }
 };
 
+// src/logger.ts
+var noopLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+
 // src/auth/AuthStateManager.ts
 var import_node_events = require("events");
 var AuthStateManager = class {
@@ -343,6 +355,7 @@ var AuthCore = class {
     this.state = opts.stateManager ?? new AuthStateManager();
     this.tokenStore = opts.tokenStore;
     this.accessControl = opts.accessControl;
+    this.logger = opts.logger ?? noopLogger;
   }
   /** Snapshot of every account, the active provider, and the last error. */
   status() {
@@ -364,16 +377,28 @@ var AuthCore = class {
    */
   async login(provider, ui, shouldContinue) {
     const providerImpl = this.registry.get(provider);
+    this.logger.info("[AuthCore] Starting device-flow login", { provider });
     try {
       const initial = await providerImpl.requestDeviceFlow();
       await ui(initial);
+      if (!initial.deviceCode) {
+        this.logger.error("[AuthCore] Provider did not return deviceCode", provider);
+        throw new Error("Auth provider did not return deviceCode for device flow completion");
+      }
       const session = await providerImpl.completeDeviceFlow(
-        initial.userCode ? initial.deviceCode ?? "" : "",
-        shouldContinue
+        initial.deviceCode,
+        shouldContinue,
+        initial.pollIntervalMs
       );
-      return await this.persistSession(providerImpl, session);
+      const result = await this.persistSession(providerImpl, session);
+      this.logger.info("[AuthCore] Device-flow login completed", { provider });
+      return result;
     } catch (err) {
-      this.state.recordError(err instanceof Error ? err.message : String(err));
+      const message = err instanceof Error ? err.message : String(err);
+      this.logger.error("[AuthCore] Device-flow login failed", message, {
+        provider
+      });
+      this.state.recordError(message);
       throw err;
     }
   }
@@ -398,7 +423,10 @@ var AuthCore = class {
     if (!provider) return null;
     const account = this.state.getActiveAccount();
     if (!account) return null;
-    const envelope = await this.tokenStore.get({ provider, accountId: account.id });
+    const envelope = await this.tokenStore.get({
+      provider,
+      accountId: account.id
+    });
     if (!envelope) return null;
     return { provider, account, token: envelope.token };
   }
@@ -408,9 +436,15 @@ var AuthCore = class {
    * every account.
    */
   async logout(provider) {
+    this.logger.info("[AuthCore] Logout requested", {
+      provider: provider ?? "all"
+    });
     if (!provider) {
       for (const account of this.state.listAccounts()) {
-        await this.tokenStore.delete({ provider: account.provider, accountId: account.id });
+        await this.tokenStore.delete({
+          provider: account.provider,
+          accountId: account.id
+        });
         this.state.removeAccount(account.provider, account.id);
       }
       this.state.clearAll();
@@ -485,6 +519,10 @@ var AuthCore = class {
       avatarUrl: meta.avatarUrl,
       expiresAt: meta.expiresAt ?? expiresAt
     };
+    this.logger.debug("[AuthCore] Persisting session", {
+      provider: meta.provider,
+      accountId: meta.id
+    });
     await this.tokenStore.set({ provider: meta.provider, accountId: meta.id }, session.token, {
       expiresAt
     });
@@ -587,11 +625,13 @@ var GitHubAuthProvider = class {
       userUrl: config.userUrl ?? DEFAULT_USER_URL,
       scope: config.scope ?? DEFAULT_SCOPE,
       minPollIntervalMs: config.minPollIntervalMs ?? 1e3,
-      maxPollIntervalMs: config.maxPollIntervalMs ?? 15e3,
+      maxPollIntervalMs: config.maxPollIntervalMs ?? 6e4,
       maxWaitMs: config.maxWaitMs,
       fetchImpl: config.fetchImpl ?? fetch,
       deviceCodeRetryBaseDelayMs: config.deviceCodeRetryBaseDelayMs ?? DEFAULT_DEVICE_CODE_RETRY_BASE_DELAY_MS
     };
+    this.logger = config.logger ?? noopLogger;
+    this.sleepImpl = config.sleepImpl ?? sleep;
   }
   async requestDeviceFlow(opts) {
     const body = JSON.stringify({
@@ -600,6 +640,10 @@ var GitHubAuthProvider = class {
     });
     let lastNetworkError;
     for (let attempt = 1; attempt <= DEVICE_CODE_MAX_ATTEMPTS; attempt++) {
+      this.logger.debug("[GitHubAuthProvider] Requesting device code", {
+        attempt,
+        maxAttempts: DEVICE_CODE_MAX_ATTEMPTS
+      });
       let resp;
       try {
         resp = await this.cfg.fetchImpl(this.cfg.deviceCodeUrl, {
@@ -613,45 +657,99 @@ var GitHubAuthProvider = class {
         });
       } catch (error) {
         if (!isTransientNetworkError(error) || attempt === DEVICE_CODE_MAX_ATTEMPTS) {
+          this.logger.error(
+            "[GitHubAuthProvider] Device-code request failed (non-retryable)",
+            error instanceof Error ? error.message : String(error),
+            { attempt }
+          );
           throw error;
         }
+        const delayMs = this.cfg.deviceCodeRetryBaseDelayMs * 2 ** (attempt - 1);
+        this.logger.warn(
+          "[GitHubAuthProvider] Transient network error requesting device code, retrying",
+          {
+            attempt,
+            delayMs,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
         lastNetworkError = error;
-        await sleep(this.cfg.deviceCodeRetryBaseDelayMs * 2 ** (attempt - 1));
+        await this.sleepImpl(delayMs);
         continue;
       }
       if (!resp.ok) {
+        this.logger.error(
+          "[GitHubAuthProvider] Device-code request rejected by GitHub",
+          `HTTP ${resp.status}`
+        );
         throw new Error(`GitHub device-code request failed: HTTP ${resp.status}`);
       }
       const data = await resp.json();
       if (!data.device_code || !data.user_code || !data.verification_uri) {
+        this.logger.error(
+          "[GitHubAuthProvider] Device-code response missing required fields",
+          JSON.stringify(Object.keys(data))
+        );
         throw new Error("GitHub device-code response missing required fields");
       }
+      this.logger.info("[GitHubAuthProvider] Device code obtained", {
+        userCode: data.user_code,
+        verificationUri: data.verification_uri,
+        expiresInSec: data.expires_in,
+        pollIntervalSec: data.interval
+      });
       return {
         provider: this.providerId,
+        deviceCode: data.device_code,
         userCode: data.user_code,
         verificationUrl: data.verification_uri,
         expiresAt: Date.now() + data.expires_in * 1e3,
+        pollIntervalMs: data.interval * 1e3,
         message: `Open ${data.verification_uri} and enter ${data.user_code}`
       };
     }
     throw lastNetworkError ?? new Error("GitHub device-code request failed");
   }
-  async completeDeviceFlow(deviceCode, shouldContinue) {
+  async completeDeviceFlow(deviceCode, shouldContinue, initialPollIntervalMs) {
     const start = Date.now();
-    let pollIntervalMs = this.cfg.minPollIntervalMs;
+    let pollIntervalMs = Math.max(this.cfg.minPollIntervalMs, initialPollIntervalMs ?? 0);
     let consecutiveSlowDown = 0;
+    let pollCount = 0;
+    this.logger.info("[GitHubAuthProvider] Starting device-flow polling", {
+      initialPollIntervalMs: pollIntervalMs,
+      maxWaitMs: this.cfg.maxWaitMs
+    });
     while (true) {
       if (shouldContinue && !shouldContinue()) {
+        this.logger.info("[GitHubAuthProvider] Device flow cancelled by caller", {
+          elapsedMs: Date.now() - start,
+          pollCount
+        });
         throw new Error("GitHub device flow cancelled by caller");
       }
       const elapsed = Date.now() - start;
       if (this.cfg.maxWaitMs !== void 0 && elapsed > this.cfg.maxWaitMs) {
+        this.logger.warn("[GitHubAuthProvider] Device flow exceeded max wait time", {
+          elapsedMs: elapsed,
+          maxWaitMs: this.cfg.maxWaitMs,
+          pollCount
+        });
         throw new Error("GitHub device flow exceeded max wait time");
       }
-      await sleep(pollIntervalMs);
+      await this.sleepImpl(pollIntervalMs);
       if (shouldContinue && !shouldContinue()) {
+        this.logger.info("[GitHubAuthProvider] Device flow cancelled by caller", {
+          elapsedMs: Date.now() - start,
+          pollCount
+        });
         throw new Error("GitHub device flow cancelled by caller");
       }
+      pollCount++;
+      this.logger.debug("[GitHubAuthProvider] Polling for authorization", {
+        pollCount,
+        elapsedMs: Date.now() - start,
+        pollIntervalMs
+      });
       let resp;
       try {
         resp = await this.cfg.fetchImpl(this.cfg.tokenUrl, {
@@ -669,19 +767,59 @@ var GitHubAuthProvider = class {
         });
       } catch (error) {
         if (!isTransientNetworkError(error)) {
+          this.logger.error(
+            "[GitHubAuthProvider] Non-retryable error while polling token endpoint",
+            error instanceof Error ? error.message : String(error),
+            { pollCount }
+          );
           throw error;
         }
-        pollIntervalMs = Math.min(Math.round(pollIntervalMs * 1.5), this.cfg.maxPollIntervalMs);
+        const nextPollIntervalMs = Math.min(
+          Math.round(pollIntervalMs * 1.5),
+          this.cfg.maxPollIntervalMs
+        );
+        this.logger.warn(
+          "[GitHubAuthProvider] Transient network error while polling, backing off",
+          {
+            pollCount,
+            error: error instanceof Error ? error.message : String(error),
+            previousPollIntervalMs: pollIntervalMs,
+            nextPollIntervalMs
+          }
+        );
+        pollIntervalMs = nextPollIntervalMs;
         continue;
       }
       if (!resp.ok) {
-        pollIntervalMs = Math.min(Math.round(pollIntervalMs * 1.5), this.cfg.maxPollIntervalMs);
+        const nextPollIntervalMs = Math.min(
+          Math.round(pollIntervalMs * 1.5),
+          this.cfg.maxPollIntervalMs
+        );
+        this.logger.warn(
+          "[GitHubAuthProvider] Token endpoint returned non-OK status, backing off",
+          {
+            pollCount,
+            status: resp.status,
+            previousPollIntervalMs: pollIntervalMs,
+            nextPollIntervalMs
+          }
+        );
+        pollIntervalMs = nextPollIntervalMs;
         continue;
       }
       const data = await resp.json();
       if (data.access_token) {
+        this.logger.info("[GitHubAuthProvider] Authorization granted, fetching user profile", {
+          pollCount,
+          elapsedMs: Date.now() - start
+        });
         const rawUser = await this.fetchGitHubUser(data.access_token);
         const email = await this.resolveEmail(data.access_token, rawUser);
+        this.logger.info("[GitHubAuthProvider] Device-flow login completed", {
+          pollCount,
+          elapsedMs: Date.now() - start,
+          login: rawUser.login
+        });
         return {
           token: data.access_token,
           refreshToken: data.refresh_token,
@@ -696,22 +834,42 @@ var GitHubAuthProvider = class {
         };
       }
       if (data.error === "authorization_pending") {
+        this.logger.debug("[GitHubAuthProvider] Authorization still pending", {
+          pollCount,
+          elapsedMs: Date.now() - start
+        });
         continue;
       }
       if (data.error === "slow_down") {
         consecutiveSlowDown++;
-        pollIntervalMs = Math.min(
-          Math.round(pollIntervalMs * 1.5 + Math.min(consecutiveSlowDown * 500, 2e3)),
-          this.cfg.maxPollIntervalMs
-        );
+        const nextPollIntervalMs = Math.min(pollIntervalMs + 5e3, this.cfg.maxPollIntervalMs);
+        this.logger.warn("[GitHubAuthProvider] GitHub requested slower polling (slow_down)", {
+          pollCount,
+          consecutiveSlowDown,
+          previousPollIntervalMs: pollIntervalMs,
+          nextPollIntervalMs
+        });
+        pollIntervalMs = nextPollIntervalMs;
         continue;
       }
       if (data.error === "access_denied") {
+        this.logger.warn("[GitHubAuthProvider] User denied authorization", {
+          pollCount
+        });
         throw new Error("User denied authorization");
       }
       if (data.error === "expired_token") {
+        this.logger.warn(
+          "[GitHubAuthProvider] Device code expired before authorization completed",
+          { pollCount, elapsedMs: Date.now() - start }
+        );
         throw new Error("GitHub device code expired \u2014 restart the flow");
       }
+      this.logger.error(
+        "[GitHubAuthProvider] Unexpected device-flow error from token endpoint",
+        data.error ?? "unknown",
+        { pollCount }
+      );
       throw new Error(`GitHub device flow error: ${data.error ?? "unknown"}`);
     }
   }