@open-webapp/drive-sync 0.5.3 → 0.5.5

package/dist/connection.js

@@ -9,12 +9,19 @@ const TOKEN_REUSE_BUFFER_MS = 5 * 60 * 1000;
  * 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 +102,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/errors.d.ts

@@ -46,6 +46,15 @@ export declare class NotFoundError extends DriveSyncError {
     fileId: string;
     constructor(fileId: string, opts?: DriveSyncErrorOptions);
 }
+/**
+ * Thrown when Drive refuses to serve a file's raw bytes via `alt=media`
+ * because it isn't binary content (e.g. a native Google Docs/Sheets/Slides
+ * file, which only supports Export, not Download).
+ */
+export declare class NotDownloadableError extends DriveSyncError {
+    fileId: string;
+    constructor(fileId: string, opts?: DriveSyncErrorOptions);
+}
 export interface RateLimitedErrorOptions extends DriveSyncErrorOptions {
     retryAfter?: number;
 }

package/dist/errors.js

@@ -59,6 +59,19 @@ export class NotFoundError extends DriveSyncError {
         this.fileId = fileId;
     }
 }
+/**
+ * Thrown when Drive refuses to serve a file's raw bytes via `alt=media`
+ * because it isn't binary content (e.g. a native Google Docs/Sheets/Slides
+ * file, which only supports Export, not Download).
+ */
+export class NotDownloadableError extends DriveSyncError {
+    fileId;
+    constructor(fileId, opts) {
+        super(`File not downloadable as raw content: ${fileId}`, { status: 403, ...opts });
+        this.name = 'NotDownloadableError';
+        this.fileId = fileId;
+    }
+}
 /** Thrown on a 429 response. */
 export class RateLimitedError extends DriveSyncError {
     retryAfter;

package/dist/files.d.ts

@@ -18,7 +18,9 @@ export interface ReadOptions extends BaseCallOptions {
  * since Drive 404s both for a genuinely wrong id and for a file the
  * connected account cannot see — this ambiguity is documented in the public
  * API and callers are expected to treat `null` as "not available" rather
- * than distinguishing the two cases.
+ * than distinguishing the two cases. Also returns `null` for a native Google
+ * Workspace file (Docs/Sheets/Slides/...), since those only support Export,
+ * not the raw `alt=media` download this function issues.
  */
 export declare function read(opts: ReadOptions): Promise<string | Blob | null>;
 export interface RemoveOptions extends BaseCallOptions {

package/dist/files.js

@@ -1,6 +1,6 @@
 import { driveFetch } from './http.js';
 import { escapeQ } from './query.js';
-import { NotFoundError, RemoteChangedError } from './errors.js';
+import { NotFoundError, NotDownloadableError, RemoteChangedError } from './errors.js';
 import { getFileState, setFileState, clearFileState } from './storage.js';
 const DRIVE_BASE = 'https://www.googleapis.com/drive/v3';
 const UPLOAD_BASE = 'https://www.googleapis.com/upload/drive/v3';
@@ -53,7 +53,9 @@ async function recordBaseline(opts, fileId, version) {
  * since Drive 404s both for a genuinely wrong id and for a file the
  * connected account cannot see — this ambiguity is documented in the public
  * API and callers are expected to treat `null` as "not available" rather
- * than distinguishing the two cases.
+ * than distinguishing the two cases. Also returns `null` for a native Google
+ * Workspace file (Docs/Sheets/Slides/...), since those only support Export,
+ * not the raw `alt=media` download this function issues.
  */
 export async function read(opts) {
     try {
@@ -88,7 +90,7 @@ export async function read(opts) {
         return content;
     }
     catch (err) {
-        if (err instanceof NotFoundError) {
+        if (err instanceof NotFoundError || err instanceof NotDownloadableError) {
             return null;
         }
         throw err;

package/dist/http.js

@@ -1,7 +1,7 @@
 import { acquireToken } from './token.js';
 import { getConnection, refreshSilently } from './connection.js';
 import { clearToken, getToken } from './storage.js';
-import { DriveSyncError, NeedsReauthError, ScopeInsufficientError, NotFoundError, RateLimitedError, TransientError, WrongAccountError, } from './errors.js';
+import { DriveSyncError, NeedsReauthError, ScopeInsufficientError, NotFoundError, NotDownloadableError, RateLimitedError, TransientError, WrongAccountError, } from './errors.js';
 const MAX_ATTEMPTS = 3;
 const BASE_DELAY_MS = 500;
 /** Mirrors connection.ts's own buffer: a cached token this close to expiry is treated as unusable. */
@@ -182,6 +182,12 @@ async function performFetch(opts, accessToken, isRetryAfter401) {
                 reason: lastBodyText,
             });
         }
+        if (lastBodyText.includes('fileNotDownloadable')) {
+            // No fileId is reliably available at this layer (see the 404 case
+            // below) — files.ts re-catches this and returns null instead of
+            // rethrowing with the concrete fileId, so the empty default is fine.
+            throw new NotDownloadableError('', { status: 403, reason: lastBodyText });
+        }
         throw new DriveSyncError(`Drive request forbidden (403): ${lastBodyText}`, {
             status: 403,
             reason: lastBodyText,

package/dist/index.js

@@ -227,7 +227,11 @@ export function createDriveSync(options) {
                 });
                 const results = [];
                 for (const p of picked) {
-                    const content = await filesImpl.read({ ...base, fileId: p.fileId, interactive: true });
+                    // Not interactive: the token above was already acquired
+                    // interactively moments ago for the Picker itself and is now
+                    // cached, so each file read reuses it (or silently refreshes)
+                    // instead of forcing its own consent prompt per file.
+                    const content = await filesImpl.read({ ...base, fileId: p.fileId, interactive: false });
                     results.push({ fileId: p.fileId, name: p.name, mimeType: p.mimeType, content });
                 }
                 return results;

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
@@ -107,32 +118,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.

package/package.json

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