@makefully/adaptfully 2.1.0 → 3.0.1

package/bin/adaptfully.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { adaptfullyFromCli } from '../lib/node/pipeline.js';
+
+adaptfullyFromCli().catch((err) => {
+    console.error(err.message || err);
+    process.exit(1);
+});

package/bin/wrapfully-deploy.js

@@ -1,7 +1,22 @@
-#!/usr/bin/env node
-import { deployFromCli } from '../lib/node/deploy.js';
-
-deployFromCli().catch((err) => {
-    console.error(err);
-    process.exit(1);
-});
+#!/usr/bin/env node
+import { loadProjectConfig, resolveServerUrl } from '../lib/node/config.js';
+import { runAdaptfullyStage } from '../lib/node/pipeline.js';
+import { resolveCliPlatformAndBuilder } from '../lib/node/registrations.js';
+
+const arg = process.argv[2] ?? 'steam';
+const cliServer = process.argv[3];
+const mode = process.argv[4] ?? 'extract';
+
+const { pkg, wrapfullyConfig } = await loadProjectConfig();
+const { platformKey, builder } = resolveCliPlatformAndBuilder(arg, pkg);
+
+runAdaptfullyStage('deploy', platformKey, {
+    pkg,
+    deployFolder: pkg.config?.deployFolder || 'deploy',
+    server: resolveServerUrl(wrapfullyConfig, cliServer),
+    mode,
+    builder,
+}).catch((err) => {
+    console.error(err.message || err);
+    process.exit(1);
+});

package/lib/node/archive.js

@@ -1,34 +1,43 @@
-import archiver from 'archiver';
-import fs from 'node:fs';
-
-/**
- * @param {string} deployFolder
- * @param {string} contents - serialized package.json for the zip
- */
-export function createArchive(deployFolder, contents) {
-    const zip = archiver('zip', { zlib: { level: 0 } });
-
-    zip.on('warning', (err) => {
-        if (err.code === 'ENOENT') {
-            console.log(err);
-            return;
-        }
-        throw err;
-    });
-    zip.on('error', (err) => {
-        throw err;
-    });
-    zip.on('close', () => {
-        console.log(`Zipped ${zip.pointer()} total bytes`);
-    });
-
-    zip.directory(`${deployFolder}/`, 'deploy');
-    zip.file(`${deployFolder}/index.html`, { name: 'deploy/index.html' });
-    if (fs.existsSync('assets/meta/')) {
-        zip.directory('assets/meta/', 'meta');
-    }
-    zip.append(contents, { name: 'package.json' });
-    zip.finalize();
-
-    return zip;
-}
+import archiver from 'archiver';
+import fs from 'node:fs';
+
+/**
+ * @param {string} deployFolder
+ * @param {string} contents - serialized package.json for the zip
+ * @param {{ indexHtml?: string }} [options]
+ */
+export function createArchive(deployFolder, contents, options = {}) {
+    const zip = archiver('zip', { zlib: { level: 0 } });
+
+    zip.on('warning', (err) => {
+        if (err.code === 'ENOENT') {
+            console.log(err);
+            return;
+        }
+        throw err;
+    });
+    zip.on('error', (err) => {
+        throw err;
+    });
+    zip.on('close', () => {
+        console.log(`Zipped ${zip.pointer()} total bytes`);
+    });
+
+    if (options.indexHtml != null) {
+        zip.glob('**/*', {
+            cwd: deployFolder,
+            ignore: ['index.html'],
+        }, { prefix: 'deploy' });
+        zip.append(options.indexHtml, { name: 'deploy/index.html' });
+    } else {
+        zip.directory(`${deployFolder}/`, 'deploy');
+        zip.file(`${deployFolder}/index.html`, { name: 'deploy/index.html' });
+    }
+    if (fs.existsSync('assets/meta/')) {
+        zip.directory('assets/meta/', 'meta');
+    }
+    zip.append(contents, { name: 'package.json' });
+    zip.finalize();
+
+    return zip;
+}

package/lib/node/config.js

@@ -1,42 +1,42 @@
-import fs from 'node:fs/promises';
-
-const DEFAULT_SERVER = 'http://localhost:9630/';
-
-/**
- * @param {string} [projectRoot='.']
- */
-export async function loadProjectConfig(projectRoot = '.') {
-    const pkgPath = `${projectRoot}/package.json`;
-    const wrapfullyPath = `${projectRoot}/wrapfully.json`;
-
-    const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
-    let wrapfullyConfig = {};
-
-    try {
-        wrapfullyConfig = JSON.parse(await fs.readFile(wrapfullyPath, 'utf8'));
-    } catch (err) {
-        if (/** @type {NodeJS.ErrnoException} */ (err).code !== 'ENOENT') {
-            throw err;
-        }
-    }
-
-    pkg.config = {
-        ...pkg.config,
-        ...wrapfullyConfig,
-    };
-
-    return { pkg, wrapfullyConfig };
-}
-
-/**
- * @param {{ server?: string }} wrapfullyConfig
- * @param {string} [cliServer]
- */
-export function resolveServerUrl(wrapfullyConfig, cliServer) {
-    return (
-        cliServer
-        || process.env.WRAPFULLY_SERVER
-        || wrapfullyConfig.server
-        || DEFAULT_SERVER
-    ).replace(/\/?$/, '/');
-}
+import fs from 'node:fs/promises';
+
+const DEFAULT_SERVER = 'http://localhost:9630/';
+
+/**
+ * @param {string} [projectRoot='.']
+ */
+export async function loadProjectConfig(projectRoot = '.') {
+    const pkgPath = `${projectRoot}/package.json`;
+    const wrapfullyPath = `${projectRoot}/wrapfully.json`;
+
+    const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+    let wrapfullyConfig = {};
+
+    try {
+        wrapfullyConfig = JSON.parse(await fs.readFile(wrapfullyPath, 'utf8'));
+    } catch (err) {
+        if (/** @type {NodeJS.ErrnoException} */ (err).code !== 'ENOENT') {
+            throw err;
+        }
+    }
+
+    pkg.config = {
+        ...pkg.config,
+        ...wrapfullyConfig,
+    };
+
+    return { pkg, wrapfullyConfig };
+}
+
+/**
+ * @param {{ server?: string }} wrapfullyConfig
+ * @param {string} [cliServer]
+ */
+export function resolveServerUrl(wrapfullyConfig, cliServer) {
+    return (
+        cliServer
+        || process.env.WRAPFULLY_SERVER
+        || wrapfullyConfig.server
+        || DEFAULT_SERVER
+    ).replace(/\/?$/, '/');
+}

package/lib/node/deploy.js

@@ -1,69 +1,52 @@
-import axios from 'axios';
-import fs from 'node:fs';
-import { pipeline } from 'node:stream/promises';
-import unzipper from 'unzip-stream';
-import { createArchive } from './archive.js';
-import { loadProjectConfig, resolveServerUrl } from './config.js';
-import { printBuildReport } from './report.js';
-
-/**
- * @param {string} gameId
- * @param {string} contents
- * @param {string} server
- * @param {string} builder
- * @param {string} deployFolder
- * @param {{ name: string, version: string }} pkg
- * @param {'extract' | string} mode
- */
-export async function send(gameId, contents, server, builder, deployFolder, pkg, mode = 'extract') {
-    const destination = mode === 'extract'
-        ? unzipper.Extract({ path: './output/', concurrency: 1 })
-        : fs.createWriteStream(`./output/${pkg.name}-${pkg.version}-${builder}.zip`);
-
-    const archiveStream = createArchive(deployFolder, contents);
-    const { data } = await axios.post(`${server}${builder}/${gameId}`, archiveStream, {
-        maxRedirects: 0,
-        responseType: 'stream',
-    });
-
-    archiveStream.on('close', () => {
-        console.log('completed send');
-    });
-
-    try {
-        await pipeline(data, destination);
-    } catch (err) {
-        if (/** @type {NodeJS.ErrnoException} */ (err).code === 'ECONNREFUSED') {
-            console.error(`Cannot connect to Wrapfully server "${server}"`);
-            process.exit(1);
-        }
-        throw err;
-    }
-
-    if (mode === 'extract') {
-        printBuildReport(builder, pkg);
-    }
-}
-
-/**
- * @param {string[]} [argv=process.argv]
- */
-export async function deployFromCli(argv = process.argv) {
-    const builder = argv[2] ?? 'all';
-    const cliServer = argv[3];
-    const mode = argv[4] ?? 'extract';
-
-    const { pkg, wrapfullyConfig } = await loadProjectConfig();
-    const server = resolveServerUrl(wrapfullyConfig, cliServer);
-    const deployFolder = pkg.config?.deployFolder || 'deploy';
-
-    await send(
-        `${pkg.name}-${pkg.version}`,
-        JSON.stringify(pkg),
-        server,
-        builder,
-        deployFolder,
-        pkg,
-        mode,
-    );
-}
+import axios from 'axios';
+import fs from 'node:fs';
+import path from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import unzipper from 'unzip-stream';
+import { createArchive } from './archive.js';
+import { listHtmlFilesRecursive } from './fs-utils.js';
+import { printBuildReport } from './report.js';
+
+/**
+ * @param {string} gameId
+ * @param {string} contents
+ * @param {string} server
+ * @param {string} builder
+ * @param {string} deployFolder - prebuilt deploy directory
+ * @param {{ name: string, version: string }} pkg
+ * @param {'extract' | string} mode
+ * @param {{ log?: (message: string) => void }} [options]
+ */
+export async function send(gameId, contents, server, builder, deployFolder, pkg, mode = 'extract', options = {}) {
+    const log = options.log ?? console.log;
+    const destination = mode === 'extract'
+        ? unzipper.Extract({ path: './output/', concurrency: 1 })
+        : fs.createWriteStream(`./output/${pkg.name}-${pkg.version}-${builder}.zip`);
+
+    const htmlFiles = listHtmlFilesRecursive(deployFolder);
+    log(`adaptfully: sending ${htmlFiles.length} HTML file(s) from ${path.resolve(deployFolder)}`);
+
+    const archiveStream = createArchive(deployFolder, contents);
+    const { data } = await axios.post(`${server}${builder}/${gameId}`, archiveStream, {
+        maxRedirects: 0,
+        responseType: 'stream',
+    });
+
+    archiveStream.on('close', () => {
+        log('adaptfully: upload complete');
+    });
+
+    try {
+        await pipeline(data, destination);
+    } catch (err) {
+        if (/** @type {NodeJS.ErrnoException} */ (err).code === 'ECONNREFUSED') {
+            console.error(`Cannot connect to Wrapfully server "${server}"`);
+            process.exit(1);
+        }
+        throw err;
+    }
+
+    if (mode === 'extract') {
+        printBuildReport(builder, pkg);
+    }
+}

package/lib/node/fs-utils.js

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * @param {string} src
+ * @param {string} dest
+ */
+export function copyRecursiveSync(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+
+        if (entry.isDirectory()) {
+            copyRecursiveSync(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+/**
+ * @param {string} dir
+ * @returns {string[]}
+ */
+export function listHtmlFilesRecursive(dir) {
+    /** @type {string[]} */
+    const files = [];
+
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...listHtmlFilesRecursive(fullPath));
+        } else if (entry.name.endsWith('.html')) {
+            files.push(fullPath);
+        }
+    }
+
+    return files;
+}
+
+/**
+ * @param {string} dir
+ */
+export function emptyDirSync(dir) {
+    fs.rmSync(dir, { recursive: true, force: true });
+    fs.mkdirSync(dir, { recursive: true });
+}

package/lib/node/index.js

@@ -1,18 +1,20 @@
-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';
+export { createArchive } from './archive.js';
+export { loadProjectConfig, resolveServerUrl } from './config.js';
+export { send } from './deploy.js';
+export { adaptfullyFromCli, runAdaptfullyStage } from './pipeline.js';
+export { prebuildPlatform, prebuildOutputDir, resolveHtmlInjections } from './prebuild.js';
+export { getPackageRoot, getRuntimeDir, resolveRuntimeScript } from './paths.js';
+export {
+    STANDARD_PLUGINS,
+    DEFAULT_BUILDER_PLATFORMS,
+    adaptfullyInjectionForPlatform,
+    buildAdaptfullyInjection,
+    collectRegistrationParts,
+    injectAdaptfullyRegistrations,
+    resolveBuilderForPlatform,
+    resolveCliPlatformAndBuilder,
+    resolvePlatformKey,
+    resolvePlatformRegistrationsByKey,
+    resolveRegistrationAssets,
+} from './registrations.js';
+export { printBuildReport } from './report.js';

package/lib/node/paths.js

@@ -0,0 +1,18 @@
+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');
+
+export function getPackageRoot() {
+    return PACKAGE_ROOT;
+}
+
+export function getRuntimeDir() {
+    return RUNTIME_DIR;
+}
+
+export function resolveRuntimeScript(relativePath) {
+    return path.join(RUNTIME_DIR, relativePath);
+}

package/lib/node/pipeline.js

@@ -0,0 +1,77 @@
+import { loadProjectConfig, resolveServerUrl } from './config.js';
+import { send } from './deploy.js';
+import { prebuildPlatform } from './prebuild.js';
+import { resolveBuilderForPlatform } from './registrations.js';
+
+/** @typedef {'prebuild' | 'build' | 'deploy'} AdaptfullyStage */
+
+const VALID_STAGES = new Set(['prebuild', 'build', 'deploy']);
+
+/**
+ * @param {AdaptfullyStage} stage
+ * @param {string} platformKey
+ * @param {{ pkg: object, deployFolder: string, server?: string, mode?: string, builder?: string, log?: (message: string) => void, outputRoot?: string }} options
+ */
+export async function runAdaptfullyStage(stage, platformKey, options) {
+    if (!VALID_STAGES.has(stage)) {
+        throw new Error(`Unknown adaptfully stage "${stage}". Expected: prebuild, build, or deploy.`);
+    }
+
+    const log = options.log ?? console.log;
+    const { pkg, deployFolder } = options;
+
+    const prebuiltDir = prebuildPlatform(deployFolder, platformKey, pkg, {
+        log,
+        outputRoot: options.outputRoot,
+    });
+
+    if (stage === 'prebuild') {
+        return { prebuiltDir, platformKey };
+    }
+
+    const builder = options.builder ?? resolveBuilderForPlatform(platformKey, pkg);
+    log(`adaptfully: ${stage} ${platformKey} via Wrapfully builder "${builder}"`);
+
+    await send(
+        `${pkg.name}-${pkg.version}`,
+        JSON.stringify(pkg),
+        options.server,
+        builder,
+        prebuiltDir,
+        pkg,
+        options.mode ?? 'extract',
+        { log },
+    );
+
+    return { prebuiltDir, platformKey, builder };
+}
+
+/**
+ * @param {string[]} [argv=process.argv]
+ */
+export async function adaptfullyFromCli(argv = process.argv) {
+    const stage = argv[2];
+    const platformKey = argv[3];
+    const cliServer = argv[4];
+    const mode = argv[5] ?? 'extract';
+
+    if (!stage || !platformKey) {
+        throw new Error(
+            'Usage: adaptfully <prebuild|build|deploy> <platform> [server] [mode]\n'
+            + '  prebuild  Copy deploy/ and apply platform registrations → output/<platform>-prebuild/\n'
+            + '  build     prebuild + zip and send to Wrapfully\n'
+            + '  deploy    build + platform release when credentials are present (via Wrapfully)',
+        );
+    }
+
+    const { pkg, wrapfullyConfig } = await loadProjectConfig();
+    const server = resolveServerUrl(wrapfullyConfig, cliServer);
+    const deployFolder = pkg.config?.deployFolder || 'deploy';
+
+    return runAdaptfullyStage(/** @type {AdaptfullyStage} */ (stage), platformKey, {
+        pkg,
+        deployFolder,
+        server,
+        mode,
+    });
+}

package/lib/node/prebuild.js

@@ -0,0 +1,90 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+    adaptfullyInjectionForPlatform,
+    injectAdaptfullyRegistrations,
+} from './registrations.js';
+import { copyRecursiveSync, emptyDirSync } from './fs-utils.js';
+
+/** @typedef {'prebuild' | 'build' | 'deploy'} AdaptfullyStage */
+
+const DEFAULT_HTML_INJECTIONS = ['index.html'];
+
+/**
+ * @param {{ config?: { htmlInjections?: string[] } }} pkg
+ * @returns {string[]}
+ */
+export function resolveHtmlInjections(pkg) {
+    const injections = pkg.config?.htmlInjections;
+    if (injections === undefined) {
+        return DEFAULT_HTML_INJECTIONS;
+    }
+    if (!Array.isArray(injections) || injections.length === 0) {
+        throw new Error('config.htmlInjections must be a non-empty array of paths relative to the deploy folder');
+    }
+    for (const entry of injections) {
+        if (typeof entry !== 'string' || !entry.length) {
+            throw new Error('config.htmlInjections entries must be non-empty strings');
+        }
+    }
+    return injections;
+}
+
+/**
+ * @param {string} platformKey
+ * @param {{ config?: { platforms?: Record<string, unknown>, outputFolder?: string } }} pkg
+ * @param {string} [outputRoot='output']
+ */
+export function prebuildOutputDir(platformKey, pkg, outputRoot = 'output') {
+    const outputFolder = pkg.config?.outputFolder || outputRoot;
+    return path.resolve(outputFolder, `${platformKey}-prebuild`);
+}
+
+/**
+ * @param {string} htmlPath
+ * @param {string} injection
+ */
+export function injectAdaptfullyIntoHtmlFile(htmlPath, injection) {
+    const html = fs.readFileSync(htmlPath, 'utf8');
+    const updated = injectAdaptfullyRegistrations(html, injection);
+    if (updated !== html) {
+        fs.writeFileSync(htmlPath, updated);
+    }
+}
+
+/**
+ * @param {string} deployFolder
+ * @param {string} platformKey
+ * @param {{ config?: { platforms?: Record<string, { registrations?: Record<string, string> }> } }} pkg
+ * @param {{ log?: (message: string) => void, outputRoot?: string }} [options]
+ * @returns {string} Absolute path to the prebuild output directory
+ */
+export function prebuildPlatform(deployFolder, platformKey, pkg, options = {}) {
+    const log = options.log ?? console.log;
+    const source = path.resolve(deployFolder);
+
+    if (!fs.existsSync(source)) {
+        throw new Error(`Deploy folder not found: ${source}`);
+    }
+
+    const dest = prebuildOutputDir(platformKey, pkg, options.outputRoot);
+    log(`adaptfully: prebuild ${platformKey} → ${dest}`);
+
+    emptyDirSync(dest);
+    copyRecursiveSync(source, dest);
+
+    const injection = adaptfullyInjectionForPlatform(platformKey, pkg, { log });
+    if (injection) {
+        for (const relativePath of resolveHtmlInjections(pkg)) {
+            const htmlPath = path.join(dest, relativePath);
+            if (!fs.existsSync(htmlPath)) {
+                throw new Error(`htmlInjections file not found in deploy output: ${relativePath}`);
+            }
+            log(`adaptfully: inject ${relativePath}`);
+            injectAdaptfullyIntoHtmlFile(htmlPath, injection);
+        }
+    }
+
+    log(`adaptfully: prebuild complete (${platformKey})`);
+    return dest;
+}