@makefully/adaptfully 4.2.1 → 4.3.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to this project are documented in this file.
 
+## 4.3.0 — 2026-09-11
+
+### Added
+
+- **Sequential multi-platform stages** — `adaptfully release steam,android,ios` (or `--platforms steam,android,ios`) runs each platform in order. Failures are collected; the command exits non-zero if any platform failed.
+- Multi-platform extracts land in `output/<platform>/` so sibling results are preserved. Only that folder’s prior `artifacts/` / wrapfully status files are cleared before each extract (single-platform still uses `output/`).
+
+### Changed
+
+- Build report failures throw instead of calling `process.exit`, so sequential platform runs can continue and report a summary.
+
+## 4.2.2 — 2026-09-10
+
+### Added
+
+- While a Wrapfully Yap chore is pending, poll `GET /yap/wrapfully/:choreId/logs` and print new live worker log lines.
+
 ## 4.2.1 — 2026-09-09
 
 ### Fixed

package/README.md

@@ -30,6 +30,8 @@ adaptfully prebuild web                       # deploy/ → output/web-prebuild/
 adaptfully build steam                        # Yap /yap/wrapfully chore → artifact zip
 adaptfully deploy web --deployment web-prod   # Yap deploy chore
 adaptfully release android --encrypt          # optional envelope encryption
+adaptfully release steam,android,ios          # sequential platforms; extracts to output/<platform>/
+adaptfully release --platforms steam,android  # same, flag form
 adaptfully steam-publish                      # one-time: log in with steamcmd → assets/meta/deployments/steam/steam.json
 ```
 
@@ -45,6 +47,8 @@ adaptfully steam-publish                      # one-time: log in with steamcmd
 | `android-keystore` | One-time local setup: generate debug/release keystores and write `android` `build.json` (also updates `.gitignore`) |
 | `apple-signing` | One-time local setup: CSR → Apple `.cer` → `.p12` / provisioning profiles under `ios/apple/` (also updates `.gitignore`) |
 
+Comma-separated platforms (or `--platforms`) run **sequentially**. Multi-platform extracts go to `output/<platform>/` so sibling results are not overwritten; only that folder’s prior `artifacts/` / status files are cleared before each extract. A single platform still extracts to `output/` for backward compatibility.
+
 **Server** means the Showfully Yap base (`SHOWFULLY_SERVER` / `wrapfully.json` `showfullyServer` or `server`), default `https://make.makefullystudios.com/`. Wrapfully workers claim chores with a separate service token.
 
 **Encryption (optional):** `--encrypt` or `"encrypt": true` wraps the chore to the Makefully Wrapfully fleet public key (override with `--encrypt-public-key`). Results are decrypted locally with an ephemeral `resultPriv` kept only for that chore.

package/lib/node/artifacts.js

@@ -17,13 +17,31 @@ export function buildOutputDir(pkg, outputRoot = 'output') {
 }
 
 /**
- * Remove prior Wrapfully extract artifacts so zip responses do not stack
- * nested `artifacts/` directories across runs.
+ * Where a platform's Wrapfully zip is extracted.
+ * Multi-platform runs use `output/<platformKey>/` so siblings are not overwritten.
+ * Single-platform runs keep `output/` for backward compatibility.
  *
- * @param {string} [outputRoot='output']
+ * @param {string} outputRoot
+ * @param {string} [platformKey]
+ * @param {{ multiPlatform?: boolean }} [options]
+ * @returns {string}
  */
-export function clearStaleBuildExtract(outputRoot = 'output') {
+export function resolveExtractRoot(outputRoot, platformKey, options = {}) {
     const root = path.resolve(outputRoot);
+    if (options.multiPlatform && platformKey) {
+        return path.join(root, platformKey);
+    }
+    return root;
+}
+
+/**
+ * Remove prior extract artifacts in `extractRoot` only (artifacts/, status,
+ * manifest). Does not wipe sibling platform folders under output/.
+ *
+ * @param {string} [extractRoot='output']
+ */
+export function clearStaleBuildExtract(extractRoot = 'output') {
+    const root = path.resolve(extractRoot);
     const stalePaths = [
         path.join(root, 'artifacts'),
         path.join(root, MANIFEST_NAME),
@@ -39,17 +57,34 @@ export function clearStaleBuildExtract(outputRoot = 'output') {
  * Resolve the artifact directory from a prior `adaptfully build` (or compatible zip extract).
  *
  * @param {{ name: string, version: string, config?: { outputFolder?: string } }} pkg
- * @param {{ outputRoot?: string, platformKey?: string }} [options]
+ * @param {{ outputRoot?: string, platformKey?: string, multiPlatform?: boolean }} [options]
  * @returns {string}
  */
 export function resolveBuildArtifactDir(pkg, options = {}) {
-    const artifactDir = buildOutputDir(pkg, options.outputRoot);
-    const manifestPath = path.join(artifactDir, MANIFEST_NAME);
+    const outputRoot = buildOutputDir(pkg, options.outputRoot);
+    const candidates = [];
 
-    if (!fs.existsSync(manifestPath)) {
+    if (options.platformKey) {
+        candidates.push(resolveExtractRoot(outputRoot, options.platformKey, { multiPlatform: true }));
+    }
+    candidates.push(outputRoot);
+
+    let artifactDir = null;
+    let manifestPath = null;
+
+    for (const candidate of candidates) {
+        const candidateManifest = path.join(candidate, MANIFEST_NAME);
+        if (fs.existsSync(candidateManifest)) {
+            artifactDir = candidate;
+            manifestPath = candidateManifest;
+            break;
+        }
+    }
+
+    if (!artifactDir || !manifestPath) {
         throw new Error(
             'No prior build artifact found in '
-            + `${artifactDir}. Run \`adaptfully build <platform>\` first or pass --artifact <path>.`,
+            + `${candidates.join(' or ')}. Run \`adaptfully build <platform>\` first or pass --artifact <path>.`,
         );
     }
 
@@ -77,3 +112,14 @@ export function resolveBuildArtifactDir(pkg, options = {}) {
 
     return artifactDir;
 }
+
+/**
+ * @param {string} value
+ * @returns {string[]}
+ */
+export function parsePlatformList(value) {
+    return String(value ?? '')
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}

package/lib/node/deploy.js

@@ -110,6 +110,7 @@ export async function submitWrapfullyChore ({
     log(`adaptfully: chore ${choreId} submitted; waiting…`);
 
     let lastStatus = '';
+    let logAfter = 0;
 
     for (;;) {
         const statusUrl = `${base}yap/wrapfully/${encodeURIComponent(choreId)}/status`;
@@ -125,6 +126,28 @@ export async function submitWrapfullyChore ({
             throw new Error(status.errors?.[0] || `Chore ${choreId} failed`);
         }
 
+        if (status?.state === 'pending') {
+            try {
+                const logsUrl = `${base}yap/wrapfully/${encodeURIComponent(choreId)}/logs?after=${logAfter}`;
+                const {data: logs} = await axios.get(logsUrl, {
+                    headers: {Authorization: `Bearer ${accessToken}`},
+                    validateStatus: () => true,
+                });
+
+                if (Array.isArray(logs?.lines) && logs.lines.length) {
+                    for (const line of logs.lines) {
+                        const text = line?.message || JSON.stringify(line);
+
+                        log(`adaptfully: ${text}`);
+                    }
+                    logAfter = logs.after ?? logAfter;
+                    lastStatus = '';
+                }
+            } catch (e) {
+                // live logs are best-effort
+            }
+        }
+
         const message = String(status?.status || status?.state || 'waiting');
 
         if (message !== lastStatus) {
@@ -174,6 +197,7 @@ export async function submitWrapfullyChore ({
  *   encrypt?: boolean,
  *   encryptPublicKey?: string,
  *   wrapfullyConfig?: object,
+ *   extractRoot?: string,
  * }} [options]
  */
 export async function send (
@@ -190,6 +214,7 @@ export async function send (
     const log = options.log ?? console.log;
     const platformKey = options.platformKey ?? family;
     const outputRoot = pkg.config?.outputFolder || 'output';
+    const extractRoot = path.resolve(options.extractRoot || outputRoot);
     const accessToken = options.accessToken;
 
     if (!accessToken) {
@@ -197,7 +222,8 @@ export async function send (
     }
 
     if (mode === 'extract') {
-        clearStaleBuildExtract(outputRoot);
+        fs.mkdirSync(extractRoot, { recursive: true });
+        clearStaleBuildExtract(extractRoot);
     }
 
     let archiveStream;
@@ -313,8 +339,8 @@ export async function send (
     }
 
     const destination = mode === 'extract'
-        ? unzipper.Extract({path: `${outputRoot}/`, concurrency: 1})
-        : fs.createWriteStream(`${outputRoot}/${pkg.name}-${pkg.version}-${stage}-${family}.zip`);
+        ? unzipper.Extract({path: `${extractRoot}/`, concurrency: 1})
+        : fs.createWriteStream(`${extractRoot}/${pkg.name}-${pkg.version}-${stage}-${family}.zip`);
 
     try {
         await pipeline(Readable.from(resultBuffer), destination);
@@ -325,6 +351,6 @@ export async function send (
     }
 
     if (mode === 'extract') {
-        printBuildReport(`${stage}-${family}`, pkg);
+        printBuildReport(`${stage}-${family}`, pkg, { extractRoot });
     }
 }

package/lib/node/index.js

@@ -1,4 +1,4 @@
-export { buildOutputDir, clearStaleBuildExtract, resolveBuildArtifactDir } from './artifacts.js';
+export { buildOutputDir, clearStaleBuildExtract, parsePlatformList, resolveBuildArtifactDir, resolveExtractRoot } from './artifacts.js';
 export { createArchive, createDeployArchive, createReleaseArchive, createSourceArchive } from './archive.js';
 export { loadProjectConfig, resolveServerUrl } from './config.js';
 export {
@@ -18,7 +18,7 @@ export {
     resolveMetaIcons,
     resolvePlaceholderIconPath,
 } from './icons.js';
-export { adaptfullyFromCli, parseStageArgs, resolveWrapfullyRoute, runAdaptfullyStage } from './pipeline.js';
+export { adaptfullyFromCli, parseStageArgs, resolveWrapfullyRoute, runAdaptfullyStage, runAdaptfullyStages } from './pipeline.js';
 export { prebuildPlatform, prebuildOutputDir, resolveHtmlInjections } from './prebuild.js';
 export { getPackageRoot, getRuntimeDir, resolveRuntimeScript } from './paths.js';
 export {

package/lib/node/pipeline.js

@@ -1,7 +1,12 @@
 import path from 'node:path';
 import { loadProjectConfig, resolveServerUrl, resolveAccessToken, resolveEncryptFlag } from './config.js';
 import { send } from './deploy.js';
-import { resolveBuildArtifactDir } from './artifacts.js';
+import {
+    buildOutputDir,
+    parsePlatformList,
+    resolveBuildArtifactDir,
+    resolveExtractRoot,
+} from './artifacts.js';
 import { prebuildPlatform } from './prebuild.js';
 import {
     resolveBuildCredentialDirs,
@@ -44,7 +49,7 @@ export function resolveWrapfullyRoute(buildSpec) {
 /**
  * @param {AdaptfullyStage} stage
  * @param {string} platformKey
- * @param {{ pkg: object, deployFolder: string, server?: string, mode?: string, deployment?: string, artifactPath?: string, log?: (message: string) => void, outputRoot?: string, accessToken?: string, encrypt?: boolean, encryptPublicKey?: string, wrapfullyConfig?: object }} options
+ * @param {{ pkg: object, deployFolder: string, server?: string, mode?: string, deployment?: string, artifactPath?: string, log?: (message: string) => void, outputRoot?: string, accessToken?: string, encrypt?: boolean, encryptPublicKey?: string, wrapfullyConfig?: object, extractRoot?: string, multiPlatform?: boolean }} options
  */
 export async function runAdaptfullyStage(stage, platformKey, options) {
     if (!VALID_STAGES.has(stage)) {
@@ -55,6 +60,9 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
     const { pkg, deployFolder } = options;
     const buildSpec = resolveBuildSpec(platformKey, pkg);
     let deployments = resolveDeploymentsForPlatform(platformKey, pkg);
+    const outputRoot = buildOutputDir(pkg, options.outputRoot);
+    const extractRoot = options.extractRoot
+        ?? resolveExtractRoot(outputRoot, platformKey, { multiPlatform: options.multiPlatform === true });
 
     if (options.deployment) {
         if (!deployments.includes(options.deployment)) {
@@ -77,6 +85,7 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
         artifactPath = resolveBuildArtifactDir(pkg, {
             outputRoot: options.outputRoot,
             platformKey,
+            multiPlatform: options.multiPlatform,
         });
     }
 
@@ -88,7 +97,7 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
         });
 
     if (stage === 'prebuild') {
-        return { prebuiltDir, platformKey, buildSpec };
+        return { prebuiltDir, platformKey, buildSpec, extractRoot };
     }
 
     const gameId = `${pkg.name}-${pkg.version}`;
@@ -97,6 +106,15 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
     const sent = [];
 
     const wrapfullyRoute = resolveWrapfullyRoute(buildSpec);
+    const sendOptionsBase = {
+        log,
+        platformKey,
+        accessToken: options.accessToken,
+        encrypt: options.encrypt,
+        encryptPublicKey: options.encryptPublicKey,
+        wrapfullyConfig: options.wrapfullyConfig,
+        extractRoot,
+    };
 
     if (stage === 'release') {
         const deploymentDirs = deployments.map((key) => resolvePublishDir(key));
@@ -111,6 +129,7 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
                 deploymentDirs.map((dir) => path.resolve(dir)).join(', ') || '(none)'
             }`,
         );
+        log(`adaptfully: extract → ${extractRoot}`);
 
         await send(
             gameId,
@@ -122,18 +141,13 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
             pkg,
             options.mode ?? 'extract',
             {
-                log,
-                platformKey,
+                ...sendOptionsBase,
                 deploymentDirs: deploymentDirs.map((dir) => path.resolve(dir)),
-                accessToken: options.accessToken,
-                encrypt: options.encrypt,
-                encryptPublicKey: options.encryptPublicKey,
-                wrapfullyConfig: options.wrapfullyConfig,
             },
         );
 
         sent.push({ deploymentKey: 'release', stage, family: buildSpec.family });
-        return { prebuiltDir, platformKey, buildSpec, deployments: sent, artifactPath };
+        return { prebuiltDir, platformKey, buildSpec, deployments: sent, artifactPath, extractRoot };
     }
 
     for (const deploymentKey of deployments) {
@@ -156,6 +170,7 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
                 }`,
             );
         }
+        log(`adaptfully: extract → ${extractRoot}`);
 
         await send(
             gameId,
@@ -167,23 +182,62 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
             pkg,
             options.mode ?? 'extract',
             {
-                log,
+                ...sendOptionsBase,
                 publishDir,
                 deploymentDirs,
-                platformKey,
                 deploymentKey: wrapStage === 'deploy' ? deploymentKey : undefined,
                 artifactPath,
-                accessToken: options.accessToken,
-                encrypt: options.encrypt,
-                encryptPublicKey: options.encryptPublicKey,
-                wrapfullyConfig: options.wrapfullyConfig,
             },
         );
 
         sent.push({ deploymentKey, stage: wrapStage, family: buildSpec.family });
     }
 
-    return { prebuiltDir, platformKey, buildSpec, deployments: sent, artifactPath };
+    return { prebuiltDir, platformKey, buildSpec, deployments: sent, artifactPath, extractRoot };
+}
+
+/**
+ * Run a stage for one or more platforms sequentially.
+ * Multi-platform extracts land in `output/<platformKey>/` so outputs do not overwrite.
+ *
+ * @param {AdaptfullyStage} stage
+ * @param {string[]} platformKeys
+ * @param {Parameters<typeof runAdaptfullyStage>[2]} options
+ */
+export async function runAdaptfullyStages(stage, platformKeys, options) {
+    const log = options.log ?? console.log;
+    const multiPlatform = platformKeys.length > 1;
+    /** @type {{ platformKey: string, ok: boolean, result?: object, error?: Error }[]} */
+    const results = [];
+
+    if (multiPlatform) {
+        log(`adaptfully: sequential ${stage} for ${platformKeys.join(', ')}`);
+    }
+
+    for (const platformKey of platformKeys) {
+        log(`adaptfully: ——— ${stage} ${platformKey} ———`);
+        try {
+            const result = await runAdaptfullyStage(stage, platformKey, {
+                ...options,
+                multiPlatform,
+            });
+            results.push({ platformKey, ok: true, result });
+        } catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            console.error(`adaptfully: ${stage} ${platformKey} failed: ${error.message}`);
+            results.push({ platformKey, ok: false, error });
+        }
+    }
+
+    const failed = results.filter((entry) => !entry.ok);
+    if (failed.length) {
+        throw new Error(
+            `adaptfully: ${failed.length}/${results.length} platform(s) failed: `
+            + failed.map((entry) => entry.platformKey).join(', '),
+        );
+    }
+
+    return results;
 }
 
 /**
@@ -202,16 +256,23 @@ export async function adaptfullyFromCli(argv = process.argv) {
     }
 
     const stage = command;
-    const { positionals, deployment, artifactPath, encrypt, encryptPublicKey } = parseStageArgs(argv.slice(3));
-    const platformKey = positionals[0];
-    const cliServer = positionals[1];
-    const mode = positionals[2] ?? 'extract';
+    const {
+        positionals,
+        deployment,
+        artifactPath,
+        encrypt,
+        encryptPublicKey,
+        platforms,
+    } = parseStageArgs(argv.slice(3));
+    const platformArg = platforms || positionals[0];
+    const cliServer = platforms ? positionals[0] : positionals[1];
+    const mode = platforms ? (positionals[1] ?? 'extract') : (positionals[2] ?? 'extract');
 
-    if (!stage || !platformKey) {
+    if (!stage || !platformArg) {
         throw new Error(
             'Usage:\n'
-            + '  adaptfully <prebuild|build|deploy|release> <platform> [showfullyServer] [mode]\n'
-            + '    [--deployment <key>] [--artifact <path>] [--encrypt] [--encrypt-public-key <pem|path>]\n'
+            + '  adaptfully <prebuild|build|deploy|release> <platform[,platform...]> [showfullyServer] [mode]\n'
+            + '    [--platforms a,b,c] [--deployment <key>] [--artifact <path>] [--encrypt] [--encrypt-public-key <pem|path>]\n'
             + '  adaptfully steam-publish [--username U] [--password P] [--deployment steam] [--output path]\n'
             + '  adaptfully google-publish [--from service-account.json] [--deployment android] [--output path]\n'
             + '  adaptfully apple-publish [--deployment ios] [--category C] [--identity I] [--username U] [--password P]\n'
@@ -224,6 +285,9 @@ export async function adaptfullyFromCli(argv = process.argv) {
             + '  deploy    Yap deploy chore with prior artifact + deployment credentials\n'
             + '  release   Yap release chore (build + configured deployments)\n'
             + '\n'
+            + '  Multiple platforms (comma-separated or --platforms) run sequentially.\n'
+            + '  Multi-platform extracts go to output/<platform>/ so siblings are preserved.\n'
+            + '\n'
             + '  --deployment <key>  Target a single named deployment.\n'
             + '  --artifact <path>   Prior build artifact directory (deploy only; default: ./output/ after build).\n'
             + '  --encrypt           Envelope-encrypt chore to Wrapfully (optional; default key embedded).\n'
@@ -242,13 +306,18 @@ export async function adaptfullyFromCli(argv = process.argv) {
         );
     }
 
+    const platformKeys = parsePlatformList(platformArg);
+    if (!platformKeys.length) {
+        throw new Error('At least one platform is required.');
+    }
+
     const { pkg, wrapfullyConfig } = await loadProjectConfig();
     const server = resolveServerUrl(wrapfullyConfig, cliServer);
     const accessToken = resolveAccessToken(wrapfullyConfig);
     const encryptFlag = resolveEncryptFlag(wrapfullyConfig, encrypt);
     const deployFolder = pkg.config?.deployFolder || 'deploy';
 
-    return runAdaptfullyStage(/** @type {AdaptfullyStage} */ (stage), platformKey, {
+    return runAdaptfullyStages(/** @type {AdaptfullyStage} */ (stage), platformKeys, {
         pkg,
         deployFolder,
         server,
@@ -264,7 +333,7 @@ export async function adaptfullyFromCli(argv = process.argv) {
 
 /**
  * @param {string[]} args
- * @returns {{ positionals: string[], deployment?: string, artifactPath?: string, encrypt?: boolean, encryptPublicKey?: string }}
+ * @returns {{ positionals: string[], deployment?: string, artifactPath?: string, encrypt?: boolean, encryptPublicKey?: string, platforms?: string }}
  */
 export function parseStageArgs(args) {
     /** @type {string[]} */
@@ -273,6 +342,7 @@ export function parseStageArgs(args) {
     let artifactPath;
     let encrypt;
     let encryptPublicKey;
+    let platforms;
 
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -281,6 +351,10 @@ export function parseStageArgs(args) {
             deployment = args[++i];
         } else if (arg.startsWith('--deployment=')) {
             deployment = arg.slice('--deployment='.length);
+        } else if (arg === '--platforms' && args[i + 1]) {
+            platforms = args[++i];
+        } else if (arg.startsWith('--platforms=')) {
+            platforms = arg.slice('--platforms='.length);
         } else if (arg === '--artifact' && args[i + 1]) {
             artifactPath = args[++i];
         } else if (arg.startsWith('--artifact=')) {
@@ -296,5 +370,5 @@ export function parseStageArgs(args) {
         }
     }
 
-    return { positionals, deployment, artifactPath, encrypt, encryptPublicKey };
+    return { positionals, deployment, artifactPath, encrypt, encryptPublicKey, platforms };
 }

package/lib/node/report.js

@@ -1,12 +1,15 @@
 import fs from 'node:fs';
+import path from 'node:path';
 
 /**
  * @param {string} builder
  * @param {{ name: string, version: string }} pkg
+ * @param {{ extractRoot?: string }} [options]
  */
-export function printBuildReport(builder, pkg) {
-    const statusPath = './output/wrapfully-status.json';
-    const legacyPath = `./output/${pkg.name}-${pkg.version}-${builder}.txt`;
+export function printBuildReport(builder, pkg, options = {}) {
+    const extractRoot = path.resolve(options.extractRoot || './output');
+    const statusPath = path.join(extractRoot, 'wrapfully-status.json');
+    const legacyPath = path.join(extractRoot, `${pkg.name}-${pkg.version}-${builder}.txt`);
 
     let status = null;
     if (fs.existsSync(statusPath)) {
@@ -30,8 +33,7 @@ export function printBuildReport(builder, pkg) {
         }
 
         if (!status.ok) {
-            console.error('Wrapfully build finished with errors.');
-            process.exit(1);
+            throw new Error('Wrapfully build finished with errors.');
         }
         return;
     }

package/package.json

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