@open-webapp/drive-sync 0.5.4 → 0.5.6

package/dist/connection.d.ts

@@ -15,8 +15,9 @@ export interface ConnectOptions {
     fetchEmail: (accessToken: string) => Promise<string>;
 }
 /**
- * Interactive connection flow: acquires a token with prompt: 'consent',
- * resolves the account email, and persists the durable Connection record.
+ * Interactive connection flow: acquires a token without forcing a consent
+ * screen, resolves the account email, and persists the durable Connection
+ * record.
  */
 export declare function connect(opts: ConnectOptions): Promise<Connection>;
 export interface RefreshSilentlyOptions {

package/dist/connection.js

@@ -5,16 +5,24 @@ import { WrongAccountError } from './errors.js';
 /** Mirrors refresh.ts's own buffer: a cached token this close to expiry is treated as unusable. */
 const TOKEN_REUSE_BUFFER_MS = 5 * 60 * 1000;
 /**
- * Interactive connection flow: acquires a token with prompt: 'consent',
- * resolves the account email, and persists the durable Connection record.
+ * Interactive connection flow: acquires a token without forcing a consent
+ * screen, resolves the account email, and persists the durable Connection
+ * record.
  */
 export async function connect(opts) {
+    // On a re-auth the previous connection's email is the account the user is
+    // expected to consent as again; pass it as a hint so the popup_closed
+    // recovery probe (token.ts) can resolve a completed grant silently even
+    // when the browser holds several Google sessions. First-time connect has
+    // no prior email and simply passes undefined.
+    const existing = await getConn(opts.appId, opts.projectId);
     const token = await acquireToken({
         appId: opts.appId,
         projectId: opts.projectId,
         clientId: opts.clientId,
         scopes: opts.scopes,
         interactive: true,
+        hint: existing?.email,
         logger: opts.logger,
     });
     const email = await opts.fetchEmail(token.accessToken);
@@ -95,12 +103,16 @@ export async function getAccessToken(opts) {
     if (cached && cached.expiresAt > Date.now() + TOKEN_REUSE_BUFFER_MS) {
         return cached.accessToken;
     }
+    // Same rationale as connect(): hand the known account email to the
+    // popup_closed recovery probe so it can pick up a completed grant silently.
+    const existing = await getConn(opts.appId, opts.projectId);
     const token = await acquireToken({
         appId: opts.appId,
         projectId: opts.projectId,
         clientId: opts.clientId,
         scopes: opts.scopes,
         interactive: opts.interactive,
+        hint: existing?.email,
         logger: opts.logger,
     });
     return token.accessToken;

package/dist/token.d.ts

@@ -33,9 +33,10 @@ export interface AcquireTokenOptions {
 export declare function notifyExternalTokenRefresh(projectId: string): void;
 /**
  * Single entry point for acquiring a Drive access token, used by BOTH the
- * interactive "connect" path (interactive: true -> prompt: 'consent', no
- * hint) and the silent "refresh" path (interactive: false -> prompt: 'none',
- * hint: the connection's known email).
+ * interactive "connect" path (interactive: true -> prompt: '', i.e. no
+ * forced consent screen) and the silent "refresh" path (interactive: false
+ * -> prompt: 'none'). Both pass `hint`: the connection's known email, when
+ * there is one.
  *
  * Design contract (see report): if `interactive` is false and GIS reports an
  * error on the silent attempt, this function throws a NeedsReauthError

package/dist/token.js

@@ -14,6 +14,17 @@ import { createBroadcast } from './broadcast.js';
  * long enough. `probeForCompletedGrant` below is what actually recovers those.
  */
 const POPUP_CLOSED_GRACE_MS = 2000;
+/**
+ * The silent `prompt: 'none'` probe that recovers a completed sign-in GIS
+ * misreported as `popup_closed` is retried a few times: GIS's popup-closed
+ * poll can fire before the just-granted consent is durably registered at
+ * Google, so a single immediate probe races the grant into existence and
+ * loses. A few spaced retries let a real grant surface while still failing
+ * fast enough that a genuine cancellation is reported promptly.
+ */
+const PROBE_ATTEMPTS = 3;
+const PROBE_RETRY_DELAY_MS = 350;
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /**
  * Persists a freshly-acquired GIS token response as a StoredToken, deriving
  * expiresAt from the response's own expires_in (never hardcoded) and
@@ -60,9 +71,10 @@ export function notifyExternalTokenRefresh(projectId) {
 }
 /**
  * Single entry point for acquiring a Drive access token, used by BOTH the
- * interactive "connect" path (interactive: true -> prompt: 'consent', no
- * hint) and the silent "refresh" path (interactive: false -> prompt: 'none',
- * hint: the connection's known email).
+ * interactive "connect" path (interactive: true -> prompt: '', i.e. no
+ * forced consent screen) and the silent "refresh" path (interactive: false
+ * -> prompt: 'none'). Both pass `hint`: the connection's known email, when
+ * there is one.
  *
  * Design contract (see report): if `interactive` is false and GIS reports an
  * error on the silent attempt, this function throws a NeedsReauthError
@@ -107,32 +119,46 @@ function isPopupClosedError(err) {
     return err instanceof NeedsReauthError && err.reason === 'popup_closed';
 }
 /**
- * Issues ONE `prompt: 'none'` request to find out whether the sign-in that
- * GIS reported as `popup_closed` actually completed. Resolves with the token
- * response when a live grant is found; otherwise rethrows `popupClosedError`
- * — the original interactive failure — so callers see the cancellation they
- * would have seen before, never a confusing silent-path error.
+ * Issues up to `PROBE_ATTEMPTS` silent `prompt: 'none'` requests to find out
+ * whether the sign-in that GIS reported as `popup_closed` actually completed.
+ * Resolves with the token response as soon as a live grant is found;
+ * otherwise rethrows `popupClosedError` — the original interactive failure —
+ * so callers see the cancellation they would have seen before, never a
+ * confusing silent-path error.
+ *
+ * `opts.hint` matters here: a bare `prompt: 'none'` request with no
+ * `login_hint` cannot be resolved by GIS when the browser holds more than one
+ * Google session, so the interactive callers pass the connection's known
+ * email through as the hint for this probe.
  */
 async function probeForCompletedGrant(initTokenClient, opts, popupClosedError) {
     opts.logger?.debug('drive-sync: popup_closed with no token; probing for a completed grant', {
         projectId: opts.projectId,
     });
-    try {
-        // No grace window: `prompt: 'none'` never opens a popup, so there is no
-        // popup-closed poll to race and nothing to wait out on failure.
-        const response = await requestGisToken(initTokenClient, opts, { prompt: 'none', hint: opts.hint }, 0);
-        opts.logger?.debug('drive-sync: recovered a completed sign-in reported as popup_closed', {
-            projectId: opts.projectId,
-        });
-        return response;
-    }
-    catch (probeError) {
-        opts.logger?.debug('drive-sync: no live grant after popup_closed; treating as cancelled', {
-            projectId: opts.projectId,
-            probeError,
-        });
-        throw popupClosedError;
+    let lastProbeError;
+    for (let attempt = 1; attempt <= PROBE_ATTEMPTS; attempt += 1) {
+        try {
+            // No grace window: `prompt: 'none'` never opens a popup, so there is no
+            // popup-closed poll to race and nothing to wait out on failure.
+            const response = await requestGisToken(initTokenClient, opts, { prompt: 'none', hint: opts.hint }, 0);
+            opts.logger?.debug('drive-sync: recovered a completed sign-in reported as popup_closed', {
+                projectId: opts.projectId,
+                attempt,
+            });
+            return response;
+        }
+        catch (probeError) {
+            lastProbeError = probeError;
+            if (attempt < PROBE_ATTEMPTS) {
+                await delay(PROBE_RETRY_DELAY_MS);
+            }
+        }
     }
+    opts.logger?.debug('drive-sync: no live grant after popup_closed; treating as cancelled', {
+        projectId: opts.projectId,
+        probeError: lastProbeError,
+    });
+    throw popupClosedError;
 }
 /**
  * Wraps a single GIS token request in a promise.
@@ -223,8 +249,19 @@ async function acquireTokenUncoalesced(opts) {
     let response;
     try {
         response = await requestGisToken(initTokenClient, opts, {
-            prompt: opts.interactive ? 'consent' : 'none',
-            hint: !opts.interactive ? opts.hint : undefined,
+            // The interactive path deliberately does NOT force `prompt: 'consent'`.
+            // Forcing the full consent screen on every connect buys nothing in the
+            // implicit (token) flow — there is no refresh token to obtain — while
+            // holding a popup open for seconds. That popup lifetime IS the window
+            // in which GIS's popup-closed poll beats delivery of the token, so
+            // forcing consent manufactures the very race the probe below recovers
+            // from. `prompt: ''` lets Google skip straight through when the grant
+            // already exists (and still shows consent on the first grant, or when
+            // new scopes are requested), which closes the race instead of racing
+            // it. The hint goes on both paths so an already-known account can skip
+            // the chooser too.
+            prompt: opts.interactive ? '' : 'none',
+            hint: opts.hint,
         });
     }
     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-webapp/drive-sync",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "type": "module",
   "repository": {
     "type": "git",