@makefully/adaptfully 3.8.2 → 3.10.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project are documented in this file.
 
+## 3.10.0 — 2026-07-17
+
+### Added
+
+- **`social-auth`** — Capgo `@capgo/capacitor-social-login` auth plugin for Capacitor platforms. Requires `packager: "capacitor"` and `platforms.<name>.socialLogin` provider config. Prebuild writes `social-login-config.js`; Wrapfully installs the native plugin when `socialLogin` is set on the build spec.
+- **`CapacitorPackager`** CSP/viewport HTML extras and social-auth validation/templates.
+
+### Changed
+
+- **Builder family defaults** — `android` / `ios` / `ios-sim` (and `-dev`) resolve to Wrapfully family **`capacitor`**. Explicit `packager: "cordova"` still selects Cordova for that platform. Composite `cordova` / `apple` routes are not used.
+- **`resolveBuildSpec`** includes `socialLogin: boolean`.
+
+## 3.9.0 — 2026-07-15
+
+### Added
+
+- **`pwa` Wrapfully family** — `resolveFamilyFromTarget('pwa')` / `resolveBuildSpec` return family `pwa` when `builder: "pwa"`, including with `packager: "web"`.
+
 ## 3.8.2 — 2026-07-14
 
 ### Fixed

package/README.md

@@ -91,7 +91,8 @@ storage.getObject('currentGame');
 |------------|--------------|---------|
 | `google-auth` | `adaptfully.register('auth', adaptfully.auth.Google)` | Web, Android, iOS |
 | `steam-auth` | `adaptfully.register('auth', adaptfully.auth.Steam)` | Steam / Electron (via [steamworks.js](https://github.com/ceifa/steamworks.js)) |
-| `dev-auth` | `adaptfully.register('auth', adaptfully.auth.Dev)` | Local dev (test user) |
+| `social-auth` | `adaptfully.register('auth', adaptfully.auth.Social)` | Capacitor (via [@capgo/capacitor-social-login](https://github.com/Cap-go/capacitor-social-login)) |
+| `dev-auth` | `adaptfully.register('auth', adaptfully.auth.Dev)` | Local / testing |
 
 Use plugin keys in `config.platforms.<platform>.registrations`. Custom deploy scripts use a path relative to the deploy folder instead:
 
@@ -133,10 +134,14 @@ Each platform entry may set a **`packager`** (`web`, `electron`, `cordova`, or `
 | `web` | `game-config.js` for **`uwp`** platform prebuilds |
 | `electron` | `main.js` (Electron shell); `preload.js` when **`steam-auth`** is registered |
 | `cordova` | `cordova.js` stub, `game-config.js`, CSP/viewport HTML extras |
-| `capacitor` | `game-config.js` (more Capacitor-specific output planned) |
+| `capacitor` | `game-config.js`, Capacitor CSP/viewport; `social-login-config.js` when **`social-auth`** is registered |
+
+Android/iOS Wrapfully builds default to the **`capacitor`** builder family. Set `packager: "cordova"` on a platform to use Cordova for that target.
 
 **`steam-auth` requires `packager: "electron"`** and `platforms.<name>.steamId` (Steamworks app ID for the client preload). Steam **upload** app IDs live separately in each Steam deployment’s `manifest.json` — see Wrapfully docs.
 
+**`social-auth` requires `packager: "capacitor"`** and `platforms.<name>.socialLogin` (Capgo provider client IDs). Wrapfully installs `@capgo/capacitor-social-login` when building.
+
 ```json
 {
   "config": {
@@ -149,6 +154,20 @@ Each platform entry may set a **`packager`** (`web`, `electron`, `cordova`, or `
         "packager": "electron",
         "steamId": 1234567,
         "registrations": { "auth": "steam-auth" }
+      },
+      "android": {
+        "packager": "capacitor",
+        "registrations": { "auth": "social-auth", "storage": "localStorage" },
+        "socialLogin": {
+          "providers": { "google": true, "apple": true },
+          "google": {
+            "webClientId": "….apps.googleusercontent.com",
+            "iOSClientId": "….apps.googleusercontent.com"
+          },
+          "apple": {
+            "clientId": "com.example.service"
+          }
+        }
       }
     }
   }
@@ -169,6 +188,17 @@ The renderer `steam-auth` plugin reads the Steam ID from that bridge. When Steam
 | `autoLoginStorageKey` | `lastLoggedIn` | Storage key written with the Steam ID on login |
 | `steamReadyTimeoutMs` | `10000` | Max wait when a bridge exists but identity is not yet ready |
 
+#### Social auth (`social-auth`)
+
+When `social-auth` is registered on a **`capacitor`** platform, Adaptfully prebuild writes **`social-login-config.js`** (`window.__ADAPTFULLY_SOCIAL_LOGIN__`) from `platforms.<name>.socialLogin`. Wrapfully installs [`@capgo/capacitor-social-login`](https://github.com/Cap-go/capacitor-social-login) and syncs it into the native project (same role as `steamworks.js` for Electron).
+
+The runtime plugin calls Capgo `SocialLogin.initialize` / `login` / `logout` / `isLoggedIn`. Default provider is `google` on Android and `apple` on iOS when both are enabled (override with `socialLogin.defaultProvider`). Optional config keys:
+
+| Key | Default | Purpose |
+|-----|---------|---------|
+| `autoLoginStorageKey` | `lastLoggedIn` | Storage key written with the user id on login |
+| `socialReadyTimeoutMs` | `10000` | Max wait for the Capgo plugin bridge |
+
 ### Node API
 
 ```javascript
@@ -211,7 +241,7 @@ After prebuild, the build and deploy stages zip `output/<platform>-prebuild/` an
 
 ```bash
 npx adaptfully prebuild web
-npx adaptfully deploy steam http://build.example.com:9630/
+npx adaptfully deploy steam http://build.example.com:9633/
 ```
 
 For web-only hosting (no Wrapfully), stop after prebuild and upload `output/web-prebuild/` yourself.
@@ -246,10 +276,10 @@ Examples:
 npx adaptfully prebuild web
 
 # Build for Steam via Wrapfully
-npx adaptfully build steam http://build.example.com:9630/
+npx adaptfully build steam http://build.example.com:9633/
 
 # Full Steam deploy (build + upload when steam.json credentials are present)
-npx adaptfully deploy steam http://build.example.com:9630/
+npx adaptfully deploy steam http://build.example.com:9633/
 ```
 
 Add scripts to your project's `package.json`:
@@ -278,7 +308,7 @@ The server URL is resolved in this order:
 1. CLI argument
 2. `WRAPFULLY_SERVER` environment variable
 3. `server` field in `wrapfully.json`
-4. `http://localhost:9630/`
+4. `http://localhost:9633/`
 
 Keep server addresses and credentials out of version control — use environment variables or a gitignored `wrapfully.json`.
 
@@ -293,7 +323,7 @@ The client POSTs a zip stream built from `output/<platform>-prebuild/` to:
 For example, a project named `mygame` at version `1.2.0` with builder `android`:
 
 ```
-http://build.example.com:9630/android/mygame-1.2.0
+http://build.example.com:9633/android/mygame-1.2.0
 ```
 
 The server extracts the zip, reads the embedded `package.json`, runs the build for that platform, and streams a zip of artifacts back to the client.
@@ -415,6 +445,7 @@ Standard npm fields (`name`, `version`, `description`) are used directly. Add a
 | `platforms.<name>.builders` | wrapfully-deploy | Map additional Wrapfully builder names to a platform |
 | `platforms.<name>.packager` | Prebuild | `web` (default), `electron`, `cordova`, or `capacitor` — selects the packager class that adds platform-specific files during prebuild |
 | `platforms.<name>.steamId` | Electron + steam-auth | Steamworks app ID baked into `preload.js` (client). Upload app IDs belong in the Steam deployment `manifest.json` |
+| `platforms.<name>.socialLogin` | Capacitor + social-auth | Capgo provider config (`providers`, `google.webClientId`, `apple.clientId`, optional `defaultProvider`) |
 | `properties` | Cordova | Cordova config.xml entries (plugins, allow-navigation, etc.) |
 
 ### `wrapfully.json`
@@ -424,7 +455,7 @@ Optional. Fields are shallow-merged into `package.json`'s `config`:
 ```json
 {
   "deployFolder": "dist",
-  "server": "http://build.example.com:9630/",
+  "server": "http://build.example.com:9633/",
   "title": "My Game",
   "packageName": "com.example.mygame"
 }
@@ -453,12 +484,8 @@ Each builder name becomes a path segment on the server. Some builds require a sp
 | `webapp` | Service-worker web app (optionally SFTP deploy) |
 | `steam` | Windows + Mac + Linux, uploads to Steam |
 | `steam-dev` | Debug Windows + Mac + Linux, no Steam upload |
-| `cordova` | Release Android + iOS |
-| `cordova-dev` | Debug Android + iOS |
-| `apple` | Release Mac + iOS |
-| `apple-dev` | Release Mac + debug iOS |
 
-For a single platform, pass the specific builder name rather than a composite.
+For a single platform, pass the specific builder name.
 
 ### Platform package requirements
 
@@ -508,7 +535,7 @@ To deploy to Google Play, also include `assets/meta/deployments/<deployment>/goo
 }
 ```
 
-#### Apple (`ios`, `ios-dev`, `ios-sim`, `mac`, `apple`, `apple-dev`)
+#### Apple (`ios`, `ios-dev`, `ios-sim`, `mac`)
 
 Include `assets/meta/deployments/<deployment>/build.json` with iOS signing settings:
 
@@ -544,9 +571,9 @@ To deploy to the App Store, include `assets/meta/deployments/<deployment>/apple.
 }
 ```
 
-#### Cordova (`cordova`, `cordova-dev`)
+#### Cordova
 
-Requires the Android and Apple package requirements above.
+Set `packager: "cordova"` on an `android` or `ios` platform to use Cordova instead of Capacitor. Requires the Android and Apple package requirements above.
 
 #### Steam (`steam`, `steam-dev`)
 

package/lib/node/config.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs/promises';
 
-const DEFAULT_SERVER = 'http://localhost:9630/';
+const DEFAULT_SERVER = 'http://localhost:9633/';
 
 /**
  * @param {string} [projectRoot='.']

package/lib/node/packagers/base.js

@@ -223,6 +223,14 @@ export class Packager {
                 + `Set config.platforms.${platformLabel}.packager to "electron".`,
             );
         }
+
+        if (this.usesPlugin('social-auth', { scope: 'all' }) && this.name !== 'capacitor') {
+            const platformLabel = this.platformKey ?? this.platforms[0] ?? 'unknown';
+            throw new Error(
+                `Platform "${platformLabel}" uses social-auth but packager is "${this.name}". `
+                + `Set config.platforms.${platformLabel}.packager to "capacitor".`,
+            );
+        }
     }
 
     needsGameConfig() {

package/lib/node/packagers/capacitor.js

@@ -1,5 +1,81 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { Packager } from './base.js';
 
+const CAPACITOR_CSP = '<meta http-equiv="Content-Security-Policy" content="default-src * \'self\' data: blob: \'unsafe-inline\' \'unsafe-eval\'; style-src * \'self\' \'unsafe-inline\'; script-src * \'self\' \'unsafe-inline\' \'unsafe-eval\'; connect-src *; img-src * data: blob:; media-src * data: blob:; frame-src *;" />';
+
+const CAPACITOR_VIEWPORT = '<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover" />';
+
+/**
+ * @param {string | null | undefined} platformKey
+ * @param {{ config?: { platforms?: Record<string, { socialLogin?: object }> } }} pkg
+ */
+export function resolvePlatformSocialLogin(platformKey, pkg) {
+    if (!platformKey) {
+        return undefined;
+    }
+    return pkg.config?.platforms?.[platformKey]?.socialLogin;
+}
+
+/**
+ * @param {object} socialLogin
+ * @param {string} platformKey
+ */
+function normalizeSocialLoginConfig(socialLogin = {}, platformKey) {
+    const providers = socialLogin.providers ?? { google: true, apple: true };
+    const googleEnabled = providers.google !== false;
+    const appleEnabled = providers.apple !== false;
+
+    let defaultProvider = socialLogin.defaultProvider;
+    if (!defaultProvider) {
+        if (platformKey === 'ios' || platformKey === 'ios-dev' || platformKey === 'ios-sim') {
+            defaultProvider = appleEnabled ? 'apple' : 'google';
+        } else {
+            defaultProvider = googleEnabled ? 'google' : 'apple';
+        }
+    }
+
+    return {
+        providers: {
+            google: googleEnabled,
+            apple: appleEnabled,
+            facebook: providers.facebook === true,
+            twitter: providers.twitter === true,
+        },
+        google: socialLogin.google ?? {},
+        apple: socialLogin.apple ?? {},
+        defaultProvider,
+        platform: platformKey,
+    };
+}
+
+/**
+ * @param {object} config
+ */
+function validateSocialLoginConfig(config) {
+    const { providers, google, apple } = config;
+
+    if (!providers.google && !providers.apple) {
+        throw new Error('social-auth requires at least one of socialLogin.providers.google or .apple');
+    }
+
+    if (providers.google) {
+        if (!google?.webClientId) {
+            throw new Error(
+                'social-auth with Google requires platforms.<key>.socialLogin.google.webClientId',
+            );
+        }
+    }
+
+    if (providers.apple && config.platform?.startsWith('android')) {
+        if (!apple?.clientId) {
+            throw new Error(
+                'social-auth with Apple on Android requires platforms.<key>.socialLogin.apple.clientId',
+            );
+        }
+    }
+}
+
 export class CapacitorPackager extends Packager {
     /** @type {'capacitor'} */
     static id = 'capacitor';
@@ -7,7 +83,57 @@ export class CapacitorPackager extends Packager {
     /** @type {string[]} */
     static defaultPlatforms = ['ios', 'android'];
 
+    validate() {
+        super.validate();
+
+        if (this.usesPlugin('social-auth')) {
+            const socialLogin = resolvePlatformSocialLogin(this.platformKey, this.pkg);
+            if (!socialLogin && !this.pkg.config?.socialLogin) {
+                const platformLabel = this.platformKey ?? this.platforms.join(', ');
+                throw new Error(
+                    `Platform "${platformLabel}" uses social-auth but platforms.${platformLabel}.socialLogin is not set.`,
+                );
+            }
+
+            const config = normalizeSocialLoginConfig(
+                socialLogin ?? this.pkg.config?.socialLogin,
+                this.platformKey ?? 'android',
+            );
+            validateSocialLoginConfig(config);
+        }
+    }
+
     needsGameConfig() {
         return true;
     }
+
+    /** @param {string} dest */
+    applyTemplates(dest) {
+        if (this.usesPlugin('social-auth') && this.platformKey) {
+            const socialLogin = resolvePlatformSocialLogin(this.platformKey, this.pkg)
+                ?? this.pkg.config?.socialLogin
+                ?? {};
+            const config = normalizeSocialLoginConfig(socialLogin, this.platformKey);
+            const content = `window.__ADAPTFULLY_SOCIAL_LOGIN__ = ${JSON.stringify(config, null, 4)};\n`;
+            fs.writeFileSync(path.join(dest, 'social-login-config.js'), content);
+            this.log('adaptfully: write social-login-config.js (social-auth)');
+        }
+
+        super.applyTemplates(dest);
+    }
+
+    buildHtmlInjection() {
+        const headExtras = [CAPACITOR_CSP, CAPACITOR_VIEWPORT];
+        const bodyScripts = [];
+
+        if (this.usesPlugin('social-auth')) {
+            bodyScripts.push('<script src="social-login-config.js"></script>');
+        }
+
+        if (this.needsGameConfig()) {
+            bodyScripts.push('<script src="game-config.js"></script>');
+        }
+
+        return this.formatHtmlInjection(headExtras, bodyScripts);
+    }
 }

package/lib/node/packagers/index.js

@@ -1,19 +1,19 @@
 import { CapacitorPackager } from './capacitor.js';
 import { CordovaPackager } from './cordova.js';
-import { ElectronPackager, buildElectronMain, buildElectronPreload } from './electron.js';
+import { ElectronPackager } from './electron.js';
 import { Packager, VALID_PACKAGERS } from './base.js';
 import { WebPackager } from './web.js';
 
-export { Packager, VALID_PACKAGERS } from './base.js';
-export { WebPackager } from './web.js';
+export { CapacitorPackager, resolvePlatformSocialLogin } from './capacitor.js';
+export { CordovaPackager } from './cordova.js';
 export {
     ElectronPackager,
     buildElectronMain,
     buildElectronPreload,
     resolvePlatformSteamId,
 } from './electron.js';
-export { CordovaPackager } from './cordova.js';
-export { CapacitorPackager } from './capacitor.js';
+export { Packager, VALID_PACKAGERS } from './base.js';
+export { WebPackager } from './web.js';
 
 /** @typedef {import('./base.js').PackagerName} PackagerName */
 
@@ -72,6 +72,13 @@ export function usesSteamAuth(registrations) {
     return Object.values(registrations).includes('steam-auth');
 }
 
+/**
+ * @param {Record<string, string>} registrations
+ */
+export function usesSocialAuth(registrations) {
+    return Object.values(registrations).includes('social-auth');
+}
+
 /**
  * @param {string} dest
  * @param {string} platformKey

package/lib/node/registrations.js

@@ -22,6 +22,10 @@ export const STANDARD_PLUGINS = {
         scripts: ['core.js', 'platform.js', 'auth/_helpers.js', 'auth/steam-auth.js'],
         registration: (key) => `adaptfully.register('${key}', adaptfully.auth.Steam);`,
     },
+    'social-auth': {
+        scripts: ['core.js', 'platform.js', 'auth/_helpers.js', 'auth/social-auth.js'],
+        registration: (key) => `adaptfully.register('${key}', adaptfully.auth.Social);`,
+    },
     'dev-auth': {
         scripts: ['core.js', 'platform.js', 'auth/_helpers.js', 'auth/dev-auth.js'],
         registration: (key) => `adaptfully.register('${key}', adaptfully.auth.Dev);`,
@@ -52,10 +56,6 @@ export const DEFAULT_BUILDER_PLATFORMS = {
     'ios-dev': 'ios',
     'ios-sim': 'ios',
     webapp: 'web',
-    cordova: 'cordova',
-    'cordova-dev': 'cordova',
-    apple: 'apple',
-    'apple-dev': 'apple',
     uwp: 'uwp',
 };
 
@@ -340,7 +340,7 @@ export function resolvePublishDir(deploymentKey, metaDir = 'assets/meta') {
 const ELECTRON_TARGETS = new Set([
     'win', 'win-dev', 'mac', 'mac-dev', 'linux', 'linux-dev',
 ]);
-const CORDOVA_TARGETS = new Set([
+const MOBILE_TARGETS = new Set([
     'android', 'android-dev', 'ios', 'ios-dev', 'ios-sim',
 ]);
 
@@ -352,8 +352,11 @@ export function resolveFamilyFromTarget(target) {
     if (ELECTRON_TARGETS.has(target)) {
         return 'electron';
     }
-    if (CORDOVA_TARGETS.has(target)) {
-        return 'cordova';
+    if (MOBILE_TARGETS.has(target)) {
+        return 'capacitor';
+    }
+    if (target === 'pwa') {
+        return 'pwa';
     }
     if (target === 'webapp' || target === 'web') {
         return 'webapp';
@@ -369,12 +372,19 @@ export function resolveFamilyFromTarget(target) {
  * @param {string} [packager]
  */
 export function resolveFamily(targets, packager) {
+    if (targets.length === 1 && targets[0] === 'pwa') {
+        return 'pwa';
+    }
+
     if (packager === 'electron') {
         return 'electron';
     }
-    if (packager === 'cordova' || packager === 'capacitor') {
+    if (packager === 'cordova') {
         return 'cordova';
     }
+    if (packager === 'capacitor') {
+        return 'capacitor';
+    }
 
     const families = [...new Set(targets.map((target) => resolveFamilyFromTarget(target)).filter(Boolean))];
 
@@ -382,27 +392,42 @@ export function resolveFamily(targets, packager) {
         return families[0];
     }
 
-    if (targets.length === 1 && targets[0] === 'webapp') {
+    if (targets.length === 1 && (targets[0] === 'webapp' || targets[0] === 'web')) {
         return 'webapp';
     }
 
     throw new Error(`Cannot resolve builder family for targets [${targets.join(', ')}]`);
 }
 
+/**
+ * @param {object | undefined} platform
+ * @returns {boolean}
+ */
+function platformUsesSocialAuth(platform) {
+    if (!platform?.registrations) {
+        return false;
+    }
+    return Object.values(platform.registrations).includes('social-auth');
+}
+
 /**
  * @param {string} platformKey
- * @param {{ config?: { platforms?: Record<string, { builder?: string | string[], packager?: string, steamworks?: boolean, deployments?: string[] }> } }} pkg
+ * @param {{ config?: { platforms?: Record<string, { builder?: string | string[], packager?: string, steamworks?: boolean, socialLogin?: boolean | object, registrations?: Record<string, string>, deployments?: string[] }> } }} pkg
  */
 export function resolveBuildSpec(platformKey, pkg) {
     const platform = pkg.config?.platforms?.[platformKey];
     const builder = platform?.builder ?? (platformKey === 'web' ? 'webapp' : platformKey);
     const targets = Array.isArray(builder) ? [...builder] : [builder];
+    const socialLogin = platform?.socialLogin === true
+        || (typeof platform?.socialLogin === 'object' && platform.socialLogin != null)
+        || platformUsesSocialAuth(platform);
 
     return {
         family: resolveFamily(targets, platform?.packager),
         targets,
         platformKey,
         steamworks: platform?.steamworks === true,
+        socialLogin,
         deployments: resolveDeploymentsForPlatform(platformKey, pkg),
     };
 }

package/lib/runtime/auth/social-auth.js

@@ -0,0 +1,313 @@
+/* global window */
+
+/**
+ * Social auth via @capgo/capacitor-social-login.
+ * Adaptfully prebuild writes social-login-config.js and Wrapfully installs the Capgo plugin
+ * when packager is "capacitor" and registrations.auth is "social-auth".
+ */
+(function registerSocialAuth(ns) {
+    const { configValue, getStorage } = ns.auth.helpers;
+
+    const DEFAULT_AUTO_LOGIN_KEY = 'lastLoggedIn';
+    const READY_POLL_MS = 50;
+    const READY_TIMEOUT_MS = 10000;
+
+    function readSocialLoginConfig() {
+        return window.__ADAPTFULLY_SOCIAL_LOGIN__ || {};
+    }
+
+    function resolveSocialLoginPlugin() {
+        const plugins = window.Capacitor?.Plugins;
+        if (plugins?.SocialLogin) {
+            return plugins.SocialLogin;
+        }
+        if (window.SocialLogin) {
+            return window.SocialLogin;
+        }
+        return null;
+    }
+
+    function mapLoginResult(result) {
+        const resultResult = result?.result ?? result;
+        const profile = resultResult?.profile
+            || resultResult?.user
+            || resultResult
+            || {};
+        const id = String(
+            profile.id
+            || profile.user
+            || profile.sub
+            || resultResult?.accessToken?.userId
+            || resultResult?.idToken
+            || '',
+        );
+        const email = String(profile.email || '');
+
+        if (!id && !email) {
+            return null;
+        }
+
+        return {
+            id: id || email,
+            email,
+            displayName: profile.name || profile.givenName || '',
+        };
+    }
+
+    class SocialAuthPlugin {
+        constructor() {
+            this.name = 'social';
+            this.user = null;
+            this.authenticated = false;
+            this.online = false;
+            this.#plugin = null;
+            this.#provider = null;
+        }
+
+        /** @type {object | null} */
+        #plugin;
+
+        /** @type {string | null} */
+        #provider;
+
+        supportsAutoLogin() {
+            return true;
+        }
+
+        #autoLoginStorageKey() {
+            return configValue('autoLoginStorageKey', DEFAULT_AUTO_LOGIN_KEY);
+        }
+
+        #config() {
+            return readSocialLoginConfig();
+        }
+
+        #resolveDefaultProvider() {
+            const config = this.#config();
+            if (config.defaultProvider) {
+                return config.defaultProvider;
+            }
+            const platform = config.platform || window.gameConfig?.platform || '';
+            if (String(platform).startsWith('ios')) {
+                return config.providers?.apple === false ? 'google' : 'apple';
+            }
+            return config.providers?.google === false ? 'apple' : 'google';
+        }
+
+        #buildInitializeOptions() {
+            const config = this.#config();
+            const options = {};
+
+            if (config.providers?.google !== false) {
+                options.google = {
+                    webClientId: config.google?.webClientId
+                        || configValue('googleClientId', ''),
+                    iOSClientId: config.google?.iOSClientId,
+                    iOSServerClientId: config.google?.iOSServerClientId
+                        || config.google?.webClientId,
+                    mode: config.google?.mode || 'online',
+                };
+            }
+
+            if (config.providers?.apple !== false) {
+                options.apple = {
+                    clientId: config.apple?.clientId || '',
+                    redirectUrl: config.apple?.redirectUrl,
+                    useProperTokenExchange: config.apple?.useProperTokenExchange !== false,
+                    useBroadcastChannel: config.apple?.useBroadcastChannel !== false,
+                };
+            }
+
+            return options;
+        }
+
+        #persistLogin(user) {
+            const storage = getStorage();
+            storage?.set(this.#autoLoginStorageKey(), user.id);
+        }
+
+        #applyIdentity(identity) {
+            if (!identity?.id) {
+                this.user = null;
+                this.authenticated = false;
+                this.online = false;
+                return false;
+            }
+
+            this.user = {
+                id: identity.id,
+                email: identity.email || '',
+                displayName: identity.displayName || '',
+            };
+            this.authenticated = true;
+            this.online = true;
+            this.#persistLogin(this.user);
+            return true;
+        }
+
+        #complete(callback) {
+            callback({
+                authenticated: this.authenticated,
+                user: this.getUser(),
+            });
+        }
+
+        whenReady(done) {
+            const started = Date.now();
+            const timeoutMs = Number(configValue('socialReadyTimeoutMs', READY_TIMEOUT_MS))
+                || READY_TIMEOUT_MS;
+
+            const finish = async () => {
+                const plugin = resolveSocialLoginPlugin();
+                if (!plugin) {
+                    if (Date.now() - started >= timeoutMs) {
+                        console.warn('[adaptfully social-auth] Capgo SocialLogin plugin not available');
+                        this.online = false;
+                        done({ error: 'SocialLogin plugin not available' });
+                        return;
+                    }
+                    window.setTimeout(finish, READY_POLL_MS);
+                    return;
+                }
+
+                this.#plugin = plugin;
+                this.#provider = this.#resolveDefaultProvider();
+
+                try {
+                    await plugin.initialize(this.#buildInitializeOptions());
+                    this.online = true;
+                    done();
+                } catch (err) {
+                    console.error('[adaptfully social-auth] initialize failed:', err);
+                    this.online = false;
+                    done({ error: err?.message || 'SocialLogin initialize failed' });
+                }
+            };
+
+            finish();
+        }
+
+        login(callback) {
+            const plugin = this.#plugin ?? resolveSocialLoginPlugin();
+            const provider = this.#provider ?? this.#resolveDefaultProvider();
+
+            if (!plugin) {
+                console.warn('[adaptfully social-auth] login: plugin missing');
+                this.#complete(callback);
+                return;
+            }
+
+            plugin.login({
+                provider,
+                options: {
+                    scopes: provider === 'google'
+                        ? ['email', 'profile']
+                        : ['email', 'name'],
+                },
+            })
+                .then((result) => {
+                    if (!this.#applyIdentity(mapLoginResult(result))) {
+                        console.warn('[adaptfully social-auth] login: could not map identity', result);
+                    }
+                    this.#complete(callback);
+                })
+                .catch((err) => {
+                    console.error('[adaptfully social-auth] login failed:', err);
+                    this.user = null;
+                    this.authenticated = false;
+                    this.online = false;
+                    this.#complete(callback);
+                });
+        }
+
+        autoLogin(callback) {
+            const plugin = this.#plugin ?? resolveSocialLoginPlugin();
+            const provider = this.#provider ?? this.#resolveDefaultProvider();
+            const storage = getStorage();
+            const lastId = storage?.get?.(this.#autoLoginStorageKey());
+
+            if (!plugin || typeof plugin.isLoggedIn !== 'function') {
+                if (lastId) {
+                    this.#applyIdentity({ id: String(lastId), email: '' });
+                }
+                this.#complete(callback);
+                return;
+            }
+
+            plugin.isLoggedIn({ provider })
+                .then(async (status) => {
+                    if (!status?.isLoggedIn) {
+                        this.user = null;
+                        this.authenticated = false;
+                        this.#complete(callback);
+                        return;
+                    }
+
+                    if (typeof plugin.getAuthorizationCode === 'function') {
+                        try {
+                            const auth = await plugin.getAuthorizationCode({ provider });
+                            const identity = mapLoginResult(auth) || (lastId
+                                ? { id: String(lastId), email: '' }
+                                : null);
+                            this.#applyIdentity(identity);
+                            this.#complete(callback);
+                            return;
+                        } catch {
+                            // fall through to lastId
+                        }
+                    }
+
+                    if (lastId) {
+                        this.#applyIdentity({ id: String(lastId), email: '' });
+                    }
+                    this.#complete(callback);
+                })
+                .catch((err) => {
+                    console.warn('[adaptfully social-auth] autoLogin failed:', err);
+                    this.#complete(callback);
+                });
+        }
+
+        logout(callback) {
+            const plugin = this.#plugin ?? resolveSocialLoginPlugin();
+            const provider = this.#provider ?? this.#resolveDefaultProvider();
+            const storage = getStorage();
+
+            const clear = () => {
+                this.user = null;
+                this.authenticated = false;
+                this.online = false;
+                storage?.remove(this.#autoLoginStorageKey());
+                callback();
+            };
+
+            if (!plugin || typeof plugin.logout !== 'function') {
+                clear();
+                return;
+            }
+
+            plugin.logout({ provider })
+                .then(clear)
+                .catch((err) => {
+                    console.warn('[adaptfully social-auth] logout failed:', err);
+                    clear();
+                });
+        }
+
+        getUser() {
+            if (!this.authenticated || !this.user) {
+                return null;
+            }
+            return {
+                id: this.user.id,
+                email: this.user.email || '',
+            };
+        }
+
+        isAuthenticated() {
+            return !!this.authenticated;
+        }
+    }
+
+    ns.auth.Social = () => new SocialAuthPlugin();
+}(window.adaptfully));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@makefully/adaptfully",
-    "version": "3.8.2",
+    "version": "3.10.0",
     "description": "Platform abstraction and Wrapfully deploy client for Makefully games",
     "type": "module",
     "main": "./lib/node/index.js",