@makefully/adaptfully 2.1.0

package/lib/node/distribution.js

@@ -0,0 +1,138 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(__dirname, '..', '..');
+const RUNTIME_DIR = path.join(PACKAGE_ROOT, 'lib', 'runtime');
+
+/** @typedef {'web' | 'steam' | 'android' | 'ios'} BuildChannel */
+
+export const VALID_CHANNELS = new Set(['web', 'steam', 'android', 'ios']);
+
+/** @type {Record<BuildChannel, string[]>} */
+const CHANNEL_EXCLUDED_AUTH = {
+    steam: ['auth/google-auth.js'],
+    web: ['auth/steam-auth.js'],
+    android: ['auth/steam-auth.js'],
+    ios: ['auth/steam-auth.js'],
+};
+
+/** @type {Record<BuildChannel, string>} */
+const CHANNEL_EXT_SCRIPTS = {
+    web: '<script src="https://accounts.google.com/gsi/client" async defer></script>\n',
+    android: '<script src="https://accounts.google.com/gsi/client" async defer></script>\n',
+    ios: '<script src="https://accounts.google.com/gsi/client" async defer></script>\n',
+};
+
+/** @type {Record<BuildChannel, string>} */
+const CHANNEL_AUTH_REGISTRATION = {
+    web: "adaptfully.register('auth', adaptfully.auth.Google);",
+    android: "adaptfully.register('auth', adaptfully.auth.Google);",
+    ios: "adaptfully.register('auth', adaptfully.auth.Google);",
+    steam: "adaptfully.register('auth', adaptfully.auth.Steam);",
+};
+
+const DEV_AUTH_REGISTRATION = "adaptfully.register('auth', adaptfully.auth.Dev);";
+
+const RUNTIME_BASE_SCRIPTS = [
+    'core.js',
+    'platform.js',
+];
+
+export function getPackageRoot() {
+    return PACKAGE_ROOT;
+}
+
+export function getRuntimeDir() {
+    return RUNTIME_DIR;
+}
+
+export function resolveRuntimeScript(relativePath) {
+    return path.join(RUNTIME_DIR, relativePath);
+}
+
+/**
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {BuildChannel}
+ */
+export function getBuildChannel(env = process.env) {
+    const channel = env.ENTANGLEMENT_CHANNEL
+        || env.VITE_ENTANGLEMENT_CHANNEL
+        || env.ADAPTFULLY_CHANNEL
+        || 'web';
+
+    if (!VALID_CHANNELS.has(channel)) {
+        throw new Error(
+            `Invalid distribution channel "${channel}". Expected one of: ${[...VALID_CHANNELS].join(', ')}`,
+        );
+    }
+
+    return /** @type {BuildChannel} */ (channel);
+}
+
+/** @param {BuildChannel} [channel] */
+export function authRegistrationForChannel(channel = getBuildChannel()) {
+    const registration = CHANNEL_AUTH_REGISTRATION[channel];
+    if (!registration) {
+        throw new Error(`No auth registration for channel: ${channel}`);
+    }
+    return registration;
+}
+
+export function devAuthRegistration() {
+    return DEV_AUTH_REGISTRATION;
+}
+
+/** @param {BuildChannel} [channel] */
+export function getAuthScriptsForChannel(channel = getBuildChannel()) {
+    const excluded = new Set(CHANNEL_EXCLUDED_AUTH[channel] ?? []);
+    const scripts = RUNTIME_BASE_SCRIPTS.map((rel) => resolveRuntimeScript(rel));
+
+    const authDir = path.join(RUNTIME_DIR, 'auth');
+    for (const file of fs.readdirSync(authDir).sort()) {
+        const rel = path.join('auth', file).replace(/\\/g, '/');
+        if (!excluded.has(rel)) {
+            scripts.push(path.join(authDir, file));
+        }
+    }
+
+    return scripts;
+}
+
+/** @param {BuildChannel} [channel] */
+export function authRegistrationScript(channel = getBuildChannel()) {
+    return authRegistrationForChannel(channel);
+}
+
+/** @param {BuildChannel} [channel] */
+export function extScriptsForBuildChannel(channel = getBuildChannel()) {
+    return CHANNEL_EXT_SCRIPTS[channel] ?? '';
+}
+
+/**
+ * @param {Array<string | { src: string }>} includes
+ * @param {BuildChannel} [channel]
+ */
+export function filterIncludesForBuildChannel(includes, channel = getBuildChannel()) {
+    if (channel !== 'steam') {
+        return includes;
+    }
+
+    return includes.filter((include) => {
+        const rel = typeof include === 'string' ? include : include.src;
+        return rel !== 'script/banner-ads.js';
+    });
+}
+
+/**
+ * @param {BuildChannel} channel
+ * @param {{ profiles: object, allExpansionsBitmask?: number }} distributionConfig
+ */
+export function distributionSettingsForBuild(channel, distributionConfig) {
+    return {
+        channel,
+        profiles: distributionConfig.profiles,
+        allExpansionsBitmask: distributionConfig.allExpansionsBitmask ?? 15,
+    };
+}

package/lib/node/index.js

@@ -0,0 +1,18 @@
+export { createArchive } from './archive.js';
+export { loadProjectConfig, resolveServerUrl } from './config.js';
+export { deployFromCli, send } from './deploy.js';
+export {
+    authRegistrationForChannel,
+    authRegistrationScript,
+    devAuthRegistration,
+    distributionSettingsForBuild,
+    extScriptsForBuildChannel,
+    filterIncludesForBuildChannel,
+    getAuthScriptsForChannel,
+    getBuildChannel,
+    getPackageRoot,
+    getRuntimeDir,
+    resolveRuntimeScript,
+    VALID_CHANNELS,
+} from './distribution.js';
+export { printBuildReport } from './report.js';

package/lib/node/report.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+
+/**
+ * @param {string} builder
+ * @param {{ name: string, version: string }} pkg
+ */
+export function printBuildReport(builder, pkg) {
+    const statusPath = './output/wrapfully-status.json';
+    const legacyPath = `./output/${pkg.name}-${pkg.version}-${builder}.txt`;
+
+    let status = null;
+    if (fs.existsSync(statusPath)) {
+        try {
+            status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+        } catch {
+            console.warn('Unable to read wrapfully-status.json');
+        }
+    }
+
+    if (status) {
+        for (const event of status.events) {
+            const line = `[${event.step}] ${event.message}`;
+            if (event.level === 'error') {
+                console.error(line);
+            } else if (event.level === 'warn') {
+                console.warn(line);
+            } else {
+                console.log(line);
+            }
+        }
+
+        if (!status.ok) {
+            console.error('Wrapfully build finished with errors.');
+            process.exit(1);
+        }
+        return;
+    }
+
+    if (fs.existsSync(legacyPath)) {
+        console.log(fs.readFileSync(legacyPath, 'utf8'));
+    }
+}

package/lib/runtime/auth/_helpers.js

@@ -0,0 +1,38 @@
+/* global window */
+
+/**
+ * @typedef {{ id: string, email: string }} AuthUser
+ * @typedef {(result: { authenticated: boolean, user?: AuthUser | null }) => void} AuthCallback
+ * @typedef {(err?: { error?: string }) => void} ReadyCallback
+ *
+ * @typedef {Object} AuthPlugin
+ * @property {string} name
+ * @property {(done: ReadyCallback) => void} whenReady
+ * @property {(callback: AuthCallback) => void} login
+ * @property {(callback: AuthCallback) => void} silentLogin
+ * @property {(callback: () => void) => void} logout
+ * @property {() => AuthUser | null} getUser
+ * @property {() => boolean} isAuthenticated
+ */
+
+(function registerAuthHelpers(ns) {
+    const helpers = {
+        configValue(key, fallback) {
+            if (!ns.has('config')) {
+                return fallback;
+            }
+            const config = ns.get('config');
+            if (config && config[key] != null) {
+                return config[key];
+            }
+            return fallback;
+        },
+
+        getStorage() {
+            return ns.has('storage') ? ns.get('storage') : null;
+        },
+    };
+
+    ns.auth = ns.auth || {};
+    ns.auth.helpers = helpers;
+}(window.adaptfully));

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

@@ -0,0 +1,78 @@
+/* global fetch, window */
+
+/**
+ * Local development auth — test values for dev builds outside the Wrapfully flow.
+ *
+ *   adaptfully.register('auth', adaptfully.auth.Dev);
+ */
+(function registerDevAuth(ns) {
+    const { getStorage } = ns.auth.helpers;
+
+    const apiBase = () => {
+        if (ns.has('config')) {
+            const config = ns.get('config');
+            if (config && typeof config.apiBase === 'string') {
+                return config.apiBase;
+            }
+        }
+        if (typeof window.__ADAPTFULLY_API__ === 'string') {
+            return window.__ADAPTFULLY_API__;
+        }
+        return '';
+    };
+
+    const apiGet = (path) => fetch(`${apiBase()}${path}`, { credentials: 'include' })
+        .then((response) => response.json());
+
+    class DevAuthPlugin {
+        constructor() {
+            this.user = { id: 'dev-local-user', email: 'dev@local' };
+            this.authenticated = true;
+        }
+
+        whenReady(done) {
+            done();
+        }
+
+        login(callback) {
+            apiGet('/get-user')
+                .then((user) => {
+                    if (user?.id) {
+                        this.user = { id: user.id, email: user.email || 'dev@local' };
+                        this.authenticated = true;
+                    }
+                    callback({ authenticated: this.authenticated, user: this.getUser() });
+                })
+                .catch(() => {
+                    this.user = { id: 'dev-local-user', email: 'dev@local' };
+                    this.authenticated = true;
+                    callback({ authenticated: true, user: this.getUser() });
+                });
+        }
+
+        silentLogin(callback) {
+            callback({ authenticated: this.authenticated, user: this.getUser() });
+        }
+
+        logout(callback) {
+            const storage = getStorage();
+            this.authenticated = false;
+            this.user = null;
+            storage?.remove('lastLoggedIn');
+            callback();
+        }
+
+        getUser() {
+            if (!this.authenticated || !this.user) {
+                return null;
+            }
+            return { id: this.user.id, email: this.user.email };
+        }
+
+        isAuthenticated() {
+            return !!this.authenticated;
+        }
+    }
+
+    ns.auth.Dev = () => new DevAuthPlugin();
+}(window.adaptfully));

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

@@ -0,0 +1,176 @@
+/* global google, sessionStorage, window */
+
+(function registerGoogleAuth(ns) {
+    const { configValue, getStorage } = ns.auth.helpers;
+
+    const DEFAULT_CLIENT_ID = '225754014403.apps.googleusercontent.com';
+    const DEFAULT_SCOPES = 'openid email profile';
+    const DEFAULT_TOKEN_KEY = 'adaptfully_google_token';
+
+    class GoogleAuthPlugin {
+        constructor() {
+            this.name = 'google';
+            this.tokenClient = null;
+            this.tokenKey = configValue('googleTokenKey', DEFAULT_TOKEN_KEY);
+            this.clientId = configValue('googleClientId', DEFAULT_CLIENT_ID);
+            this.scopes = configValue('googleScopes', DEFAULT_SCOPES);
+            this.accessToken = sessionStorage.getItem(this.tokenKey) || '';
+            this.user = null;
+            this.authenticated = false;
+        }
+
+        whenReady(done) {
+            const setup = () => {
+                this.tokenClient = google.accounts.oauth2.initTokenClient({
+                    client_id: this.clientId,
+                    scope: this.scopes,
+                    callback: () => {},
+                });
+                done();
+            };
+
+            if (window.google?.accounts?.oauth2) {
+                setup();
+                return;
+            }
+
+            let attempts = 0;
+            const timer = window.setInterval(() => {
+                attempts += 1;
+                if (window.google?.accounts?.oauth2) {
+                    window.clearInterval(timer);
+                    setup();
+                } else if (attempts > 200) {
+                    window.clearInterval(timer);
+                    console.error('Google Identity Services failed to load.');
+                    done({ error: 'Google Identity Services failed to load.' });
+                }
+            }, 50);
+        }
+
+        #applyUserInfo(data) {
+            this.user = {
+                id: data.sub || data.id || '',
+                email: data.email || '',
+            };
+            this.authenticated = !!(this.user.id && this.user.email);
+        }
+
+        #clearSession() {
+            this.accessToken = '';
+            this.user = null;
+            this.authenticated = false;
+            sessionStorage.removeItem(this.tokenKey);
+        }
+
+        #hasPersistedLogin() {
+            const storage = getStorage();
+            return !!(storage?.get('lastLoggedIn'));
+        }
+
+        #fetchUserInfo(token, callback) {
+            fetch('https://www.googleapis.com/oauth2/v3/userinfo', {
+                headers: { Authorization: `Bearer ${token}` },
+            })
+                .then((response) => {
+                    if (!response.ok) {
+                        throw new Error('userinfo failed');
+                    }
+                    return response.json();
+                })
+                .then((data) => {
+                    this.accessToken = token;
+                    sessionStorage.setItem(this.tokenKey, token);
+                    this.#applyUserInfo(data);
+                    callback();
+                })
+                .catch(() => {
+                    this.#clearSession();
+                    callback();
+                });
+        }
+
+        #requestAccessToken(prompt, callback) {
+            this.tokenClient.callback = (response) => {
+                if (response.error || !response.access_token) {
+                    this.#clearSession();
+                    callback();
+                    return;
+                }
+                this.#fetchUserInfo(response.access_token, callback);
+            };
+            this.tokenClient.requestAccessToken({ prompt: prompt || '' });
+        }
+
+        #restoreSession(callback) {
+            const trySilentGoogleLogin = () => {
+                if (this.#hasPersistedLogin()) {
+                    this.#requestAccessToken('none', callback);
+                } else {
+                    this.#clearSession();
+                    callback();
+                }
+            };
+
+            if (this.accessToken) {
+                this.#fetchUserInfo(this.accessToken, () => {
+                    if (this.authenticated) {
+                        callback();
+                        return;
+                    }
+                    trySilentGoogleLogin();
+                });
+                return;
+            }
+            trySilentGoogleLogin();
+        }
+
+        login(callback) {
+            if (this.authenticated) {
+                callback({ authenticated: true, user: this.getUser() });
+                return;
+            }
+            this.#requestAccessToken('select_account', () => {
+                callback({ authenticated: this.authenticated, user: this.getUser() });
+            });
+        }
+
+        silentLogin(callback) {
+            if (this.authenticated && this.user?.id) {
+                callback({ authenticated: true, user: this.getUser() });
+                return;
+            }
+            this.#restoreSession(() => {
+                callback({ authenticated: this.authenticated, user: this.getUser() });
+            });
+        }
+
+        logout(callback) {
+            const storage = getStorage();
+            const finish = () => {
+                this.#clearSession();
+                storage?.remove('lastLoggedIn');
+                callback();
+            };
+
+            if (this.accessToken && google.accounts?.oauth2) {
+                google.accounts.oauth2.revoke(this.accessToken, finish);
+            } else {
+                finish();
+            }
+        }
+
+        getUser() {
+            if (!this.authenticated || !this.user) {
+                return null;
+            }
+            return { id: this.user.id, email: this.user.email };
+        }
+
+        isAuthenticated() {
+            return !!this.authenticated;
+        }
+    }
+
+    ns.auth.Google = () => new GoogleAuthPlugin();
+}(window.adaptfully));

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

@@ -0,0 +1,50 @@
+/* global window */
+
+/**
+ * Steam auth plugin — placeholder for Electron / NW.js Steam deployments.
+ * Wire Steamworks login here; games only talk to adaptfully.get('auth').
+ */
+(function registerSteamAuth(ns) {
+    const { getStorage } = ns.auth.helpers;
+
+    class SteamAuthPlugin {
+        constructor() {
+            this.name = 'steam';
+            this.user = null;
+            this.authenticated = false;
+        }
+
+        whenReady(done) {
+            done();
+        }
+
+        login(callback) {
+            callback({ authenticated: this.authenticated, user: this.getUser() });
+        }
+
+        silentLogin(callback) {
+            callback({ authenticated: this.authenticated, user: this.getUser() });
+        }
+
+        logout(callback) {
+            const storage = getStorage();
+            this.user = null;
+            this.authenticated = false;
+            storage?.remove('lastLoggedIn');
+            callback();
+        }
+
+        getUser() {
+            if (!this.authenticated || !this.user) {
+                return null;
+            }
+            return { id: this.user.id, email: this.user.email || '' };
+        }
+
+        isAuthenticated() {
+            return !!this.authenticated;
+        }
+    }
+
+    ns.auth.Steam = () => new SteamAuthPlugin();
+}(window.adaptfully));

package/lib/runtime/core.js

@@ -0,0 +1,61 @@
+/* global window */
+
+/**
+ * Adaptfully — shared platform services for Makefully games.
+ *
+ *   adaptfully.register('auth', adaptfully.auth.Google);
+ *   const platform = adaptfully.get('auth');
+ */
+(function initAdaptfully(global) {
+    class Adaptfully {
+        /** @type {Record<string, unknown>} */
+        #registry = {};
+
+        /** @type {import('./platform.js').Platform | null} */
+        #authPlatform = null;
+
+        register(key, value) {
+            if (key === 'auth') {
+                this.#authPlatform = null;
+            }
+            this.#registry[key] = value;
+        }
+
+        get(key) {
+            if (key === 'auth') {
+                if (!this.#authPlatform) {
+                    const factory = this.#registry.auth;
+                    if (!factory) {
+                        throw new Error(
+                            'adaptfully: no auth registered — call adaptfully.register(\'auth\', ...) before the game loads',
+                        );
+                    }
+                    const plugin = typeof factory === 'function' ? factory() : factory;
+                    if (!this.Platform) {
+                        throw new Error('adaptfully: Platform is not loaded');
+                    }
+                    this.#authPlatform = new this.Platform(plugin);
+                }
+                return this.#authPlatform;
+            }
+
+            if (!(key in this.#registry)) {
+                throw new Error(`adaptfully: nothing registered for "${key}"`);
+            }
+            return this.#registry[key];
+        }
+
+        has(key) {
+            return key in this.#registry;
+        }
+
+        /** @deprecated Use adaptfully.get('auth') */
+        getInstance() {
+            return this.get('auth');
+        }
+    }
+
+    const adaptfully = global.adaptfully || new Adaptfully();
+    adaptfully.auth = adaptfully.auth || {};
+    global.adaptfully = adaptfully;
+}(typeof window !== 'undefined' ? window : globalThis));

package/lib/runtime/platform.js

@@ -0,0 +1,89 @@
+/* global window */
+
+(function registerPlatform(ns) {
+    class Platform {
+        /**
+         * @param {object} authPlugin
+         */
+        constructor(authPlugin) {
+            this.auth = authPlugin;
+            this.online = true;
+            this.#ready = false;
+            this.#queue = [];
+
+            authPlugin.whenReady((err) => {
+                if (err) {
+                    this.online = false;
+                }
+                this.#ready = true;
+                const queue = this.#queue;
+                this.#queue = [];
+                for (const callback of queue) {
+                    callback();
+                }
+            });
+        }
+
+        /** @type {boolean} */
+        #ready;
+
+        /** @type {Array<() => void>} */
+        #queue;
+
+        whenReady(callback) {
+            if (this.#ready) {
+                callback();
+                return;
+            }
+            this.#queue.push(callback);
+        }
+
+        login(callback) {
+            this.whenReady(() => {
+                if (!this.online) {
+                    callback({ authenticated: false });
+                    return;
+                }
+                this.auth.login((result) => {
+                    callback(result || {
+                        authenticated: this.auth.isAuthenticated(),
+                        user: this.auth.getUser(),
+                    });
+                });
+            });
+        }
+
+        silentLogin(callback) {
+            this.whenReady(() => {
+                if (!this.online) {
+                    callback({ authenticated: false });
+                    return;
+                }
+                this.auth.silentLogin((result) => {
+                    callback(result || {
+                        authenticated: this.auth.isAuthenticated(),
+                        user: this.auth.getUser(),
+                    });
+                });
+            });
+        }
+
+        logout(callback) {
+            this.whenReady(() => {
+                this.auth.logout(() => {
+                    callback({ authenticated: false });
+                });
+            });
+        }
+
+        getUser() {
+            return this.auth.getUser();
+        }
+
+        isAuthenticated() {
+            return this.auth.isAuthenticated();
+        }
+    }
+
+    ns.Platform = Platform;
+}(window.adaptfully));