@makefully/adaptfully 3.9.0 → 3.11.0

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable changes to this project are documented in this file.
 
+## 3.11.0 — 2026-07-23
+
+### Added
+
+- **Layered icon validation** — build/deploy/release zips always include `meta/icon-foreground.png` and `meta/icon-background.png`. When project icons are missing under `assets/meta/`, Adaptfully **warns** (does not fail) and ships packaged placeholder icons from `lib/assets/`.
+- **`resolveMetaIcons` / `appendMetaIcons`** — exported helpers for resolving project vs placeholder icon paths.
+
+### Changed
+
+- Legacy meta packaging skips re-adding icon filenames so placeholders and project icons are not duplicated in the zip.
+
+## 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`.
+- **Single-target Wrapfully POSTs** go to the target route (`/android/build`, `/ios/release`, …) instead of the family route (`/capacitor/...`), so OS relay and existing target routes keep working.
+
 ## 3.9.0 — 2026-07-15
 
 ### Added

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.
@@ -333,7 +363,7 @@ mygame/
 
 The selected deployment's folder is shipped as `meta/publish/` in the zip, so per-platform credential file names (`build.json`, `sftp.json`, `steam.json`, `apple.json`, `google.json`, `ms.json`, `android/`, `ms/`) live inside `assets/meta/deployments/<key>/`.
 
-Icons (`icon-foreground.png`, `icon-background.png`) are required for mobile, desktop, and Steam builds.
+Icons (`icon-foreground.png`, `icon-background.png`) are required for mobile, desktop, and Steam builds. If either file is missing from `assets/meta/`, Adaptfully **warns** and ships packaged placeholder icons for that build so Wrapfully can still run.
 
 ### Icons
 
@@ -348,6 +378,8 @@ The build server composites the foreground over the background, applies a bindin
 
 **Recommended format:** 1536×1536 pixel square PNGs for both files. Images with other dimensions are scaled to 1536×1536 automatically, but matching the target size produces the sharpest results.
 
+Missing icons do not fail the Adaptfully client: check the `WARNING missing layered icon(s)` log line and replace the placeholders before a store release.
+
 ## Configuration
 
 Build settings are read from `package.json`. The client merges any `wrapfully.json` fields into `package.json`'s `config` object before sending.
@@ -415,6 +447,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 +457,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 +486,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 +537,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 +573,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/archive.js

@@ -1,9 +1,9 @@
 import archiver from 'archiver';
 import fs from 'node:fs';
 import path from 'node:path';
+import { appendMetaIcons, isMetaIconFilename, META_DIR } from './icons.js';
 
 const
-    META_DIR = 'assets/meta',
     DEPLOYMENTS_DIRNAME = 'deployments',
     PUBLISH_DIRNAME = 'publish';
 
@@ -38,6 +38,9 @@ function appendMeta(zip, publishDir, deploymentDirs = [], options = {}) {
         log = options.log ?? (() => {}),
         metaDir = path.resolve(META_DIR);
 
+    // Always ship layered icons (project files or Adaptfully placeholders).
+    appendMetaIcons(zip, { metaDir, log });
+
     if (!fs.existsSync(metaDir)) {
         log(`adaptfully: meta dir missing at ${metaDir}; skipping credentials`);
         return;
@@ -46,7 +49,17 @@ function appendMeta(zip, publishDir, deploymentDirs = [], options = {}) {
     const deploymentsRoot = path.join(metaDir, DEPLOYMENTS_DIRNAME);
 
     if (!fs.existsSync(deploymentsRoot)) {
-        appendDirectory(zip, metaDir, 'meta');
+        for (const entry of fs.readdirSync(metaDir, { withFileTypes: true })) {
+            if (isMetaIconFilename(entry.name)) {
+                continue;
+            }
+            const fullPath = path.join(metaDir, entry.name);
+            if (entry.isDirectory()) {
+                appendDirectory(zip, fullPath, `meta/${entry.name}`);
+            } else {
+                zip.file(fullPath, { name: `meta/${entry.name}` });
+            }
+        }
         return;
     }
 
@@ -54,6 +67,9 @@ function appendMeta(zip, publishDir, deploymentDirs = [], options = {}) {
         if (entry.name === DEPLOYMENTS_DIRNAME || entry.name === PUBLISH_DIRNAME) {
             continue;
         }
+        if (isMetaIconFilename(entry.name)) {
+            continue;
+        }
 
         const fullPath = path.join(metaDir, entry.name);
         if (entry.isDirectory()) {

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/icons.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getPackageRoot } from './paths.js';
+
+export const META_DIR = 'assets/meta';
+export const ICON_FOREGROUND = 'icon-foreground.png';
+export const ICON_BACKGROUND = 'icon-background.png';
+
+const ICON_FILES = [ICON_FOREGROUND, ICON_BACKGROUND];
+
+/**
+ * Absolute path to a packaged Adaptfully placeholder icon.
+ * @param {string} filename
+ */
+export function resolvePlaceholderIconPath(filename) {
+    return path.join(getPackageRoot(), 'lib', 'assets', filename);
+}
+
+/**
+ * @param {string} [metaDir=META_DIR]
+ */
+export function resolveMetaIconPaths(metaDir = META_DIR) {
+    const root = path.resolve(metaDir);
+    return {
+        metaDir: root,
+        foreground: path.join(root, ICON_FOREGROUND),
+        background: path.join(root, ICON_BACKGROUND),
+    };
+}
+
+/**
+ * Resolve layered icon paths for Wrapfully packaging. Warns (does not throw) when
+ * project icons are missing and falls back to Adaptfully placeholders.
+ *
+ * @param {{ metaDir?: string, log?: (message: string) => void }} [options]
+ * @returns {{
+ *   metaDir: string,
+ *   foreground: string,
+ *   background: string,
+ *   missing: string[],
+ *   usedPlaceholders: boolean,
+ * }}
+ */
+export function resolveMetaIcons(options = {}) {
+    const log = options.log ?? console.log;
+    const { metaDir, foreground, background } = resolveMetaIconPaths(options.metaDir);
+    /** @type {string[]} */
+    const missing = [];
+    let resolvedForeground = foreground;
+    let resolvedBackground = background;
+
+    if (!fs.existsSync(foreground)) {
+        missing.push(ICON_FOREGROUND);
+        resolvedForeground = resolvePlaceholderIconPath(ICON_FOREGROUND);
+    }
+    if (!fs.existsSync(background)) {
+        missing.push(ICON_BACKGROUND);
+        resolvedBackground = resolvePlaceholderIconPath(ICON_BACKGROUND);
+    }
+
+    if (missing.length > 0) {
+        log(
+            `adaptfully: WARNING missing layered icon(s) in ${metaDir}: ${missing.join(', ')}. `
+            + 'Using Adaptfully placeholder icons for this build.',
+        );
+    }
+
+    return {
+        metaDir,
+        foreground: resolvedForeground,
+        background: resolvedBackground,
+        missing,
+        usedPlaceholders: missing.length > 0,
+    };
+}
+
+/**
+ * Append layered icons to a zip under meta/. Uses project icons when present;
+ * otherwise warns and ships Adaptfully placeholders.
+ *
+ * @param {import('archiver').Archiver} zip
+ * @param {{ metaDir?: string, log?: (message: string) => void }} [options]
+ * @returns {ReturnType<typeof resolveMetaIcons>}
+ */
+export function appendMetaIcons(zip, options = {}) {
+    const resolved = resolveMetaIcons(options);
+    zip.file(resolved.foreground, { name: `meta/${ICON_FOREGROUND}` });
+    zip.file(resolved.background, { name: `meta/${ICON_BACKGROUND}` });
+    return resolved;
+}
+
+/**
+ * @param {string} name
+ */
+export function isMetaIconFilename(name) {
+    return ICON_FILES.includes(name);
+}

package/lib/node/index.js

@@ -2,7 +2,17 @@ export { buildOutputDir, clearStaleBuildExtract, resolveBuildArtifactDir } from
 export { createArchive, createDeployArchive, createReleaseArchive, createSourceArchive } from './archive.js';
 export { loadProjectConfig, resolveServerUrl } from './config.js';
 export { send } from './deploy.js';
-export { adaptfullyFromCli, parseStageArgs, runAdaptfullyStage } from './pipeline.js';
+export {
+    appendMetaIcons,
+    ICON_BACKGROUND,
+    ICON_FOREGROUND,
+    isMetaIconFilename,
+    META_DIR,
+    resolveMetaIconPaths,
+    resolveMetaIcons,
+    resolvePlaceholderIconPath,
+} from './icons.js';
+export { adaptfullyFromCli, parseStageArgs, resolveWrapfullyRoute, runAdaptfullyStage } from './pipeline.js';
 export { prebuildPlatform, prebuildOutputDir, resolveHtmlInjections } from './prebuild.js';
 export { getPackageRoot, getRuntimeDir, resolveRuntimeScript } from './paths.js';
 export {

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/pipeline.js

@@ -14,6 +14,21 @@ import { steamAuthFromCli } from './steam-auth.js';
 
 const VALID_STAGES = new Set(['prebuild', 'build', 'deploy', 'release']);
 
+/**
+ * Wrapfully URL path segment for build/release.
+ * Single-target platforms post to the target route (`android`, `ios`, …) so OS relay
+ * and long-standing target routes work; multi-target platforms post to the family
+ * (`electron`, …).
+ *
+ * @param {{ family: string, targets: string[] }} buildSpec
+ */
+export function resolveWrapfullyRoute(buildSpec) {
+    if (buildSpec.targets.length === 1) {
+        return buildSpec.targets[0];
+    }
+    return buildSpec.family;
+}
+
 /**
  * @param {AdaptfullyStage} stage
  * @param {string} platformKey
@@ -69,10 +84,15 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
     /** @type {{ deploymentKey: string, stage: string, family: string }[]} */
     const sent = [];
 
+    const wrapfullyRoute = resolveWrapfullyRoute(buildSpec);
+
     if (stage === 'release') {
         const deploymentDirs = deployments.map((key) => resolvePublishDir(key));
 
-        log(`adaptfully: ${stage} ${platformKey} → ${buildSpec.family} (${buildSpec.targets.join(', ')})`);
+        log(
+            `adaptfully: ${stage} ${platformKey} → ${buildSpec.family} `
+            + `(${buildSpec.targets.join(', ')}) via /${wrapfullyRoute}/release`,
+        );
 
         log(
             `adaptfully: release deployments → ${
@@ -85,7 +105,7 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
             contents,
             options.server,
             'release',
-            buildSpec.family,
+            wrapfullyRoute,
             prebuiltDir,
             pkg,
             options.mode ?? 'extract',
@@ -107,7 +127,7 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
         log(
             `adaptfully: ${stage} ${platformKey} → `
             + `${deploymentKey === 'zip' ? 'artifact zip' : `deployment "${deploymentKey}"`} `
-            + `via Wrapfully ${buildSpec.family}`,
+            + `via Wrapfully /${wrapfullyRoute}/${wrapStage} (${buildSpec.family})`,
         );
 
         await send(
@@ -115,7 +135,7 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
             contents,
             options.server,
             wrapStage,
-            buildSpec.family,
+            wrapfullyRoute,
             prebuiltDir,
             pkg,
             options.mode ?? 'extract',
@@ -158,9 +178,9 @@ export async function adaptfullyFromCli(argv = process.argv) {
             + '\n'
             + 'Stages:\n'
             + '  prebuild  Copy deploy/ and apply platform registrations → output/<platform>-prebuild/\n'
-            + '  build     prebuild + POST /{family}/build (zip artifact only)\n'
+            + '  build     prebuild + POST /{target|family}/build (zip artifact only)\n'
             + '  deploy    POST /deploy/{key} with prior artifact + deployment credentials\n'
-            + '  release   prebuild + POST /{family}/release (build + configured deployments)\n'
+            + '  release   prebuild + POST /{target|family}/release (build + configured deployments)\n'
             + '\n'
             + '  --deployment <key>  Target a single named deployment.\n'
             + '  --artifact <path>   Prior build artifact directory (deploy only; default: ./output/ after build).\n'

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,8 @@ 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';
@@ -379,9 +379,12 @@ export function resolveFamily(targets, packager) {
     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))];
 
@@ -396,20 +399,35 @@ export function resolveFamily(targets, packager) {
     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.9.0",
+    "version": "3.11.0",
     "description": "Platform abstraction and Wrapfully deploy client for Makefully games",
     "type": "module",
     "main": "./lib/node/index.js",