@makefully/adaptfully 3.8.0 → 3.8.2

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project are documented in this file.
 
+## 3.8.2 — 2026-07-14
+
+### Fixed
+
+- **Release/deploy zips** resolve `assets/meta` and deployment credential dirs to absolute POSIX paths before `archiver.directory()`, and log which deployments were packaged (or skipped). Prevents empty `meta/deployments` payloads that made Wrapfully skip Steam.
+
+## 3.8.1 — 2026-07-14
+
+### Fixed
+
+- **Extract mode** clears stale `output/artifacts/`, `wrapfully-build.json`, and `wrapfully-status.json` before unpacking a Wrapfully response so nested `artifacts/artifacts` leftovers cannot accumulate across runs.
+
 ## 3.8.0 — 2026-07-10
 
 ### Changed

package/lib/node/archive.js

@@ -2,57 +2,98 @@ import archiver from 'archiver';
 import fs from 'node:fs';
 import path from 'node:path';
 
-const META_DIR = 'assets/meta';
-const DEPLOYMENTS_DIRNAME = 'deployments';
-const PUBLISH_DIRNAME = 'publish';
+const
+    META_DIR = 'assets/meta',
+    DEPLOYMENTS_DIRNAME = 'deployments',
+    PUBLISH_DIRNAME = 'publish';
+
+/**
+ * @param {string} dirPath
+ * @returns {string}
+ */
+function toPosixDir(dirPath) {
+    return `${path.resolve(dirPath).replace(/\\/g, '/').replace(/\/?$/, '')}/`;
+}
+
+/**
+ * @param {import('archiver').Archiver} zip
+ * @param {string} sourceDir Absolute or relative directory to pack
+ * @param {string} zipPrefix Zip entry prefix without trailing slash
+ */
+function appendDirectory(zip, sourceDir, zipPrefix) {
+    const
+        source = toPosixDir(sourceDir),
+        prefix = `${zipPrefix.replace(/\\/g, '/').replace(/\/?$/, '')}/`;
+    zip.directory(source, prefix);
+}
 
 /**
  * @param {import('archiver').Archiver} zip
  * @param {string} [publishDir] Single deployment folder
  * @param {string[]} [deploymentDirs] Multiple deployment folders for release
+ * @param {{ log?: (message: string) => void }} [options]
  */
-function appendMeta(zip, publishDir, deploymentDirs = []) {
-    if (!fs.existsSync(META_DIR)) {
+function appendMeta(zip, publishDir, deploymentDirs = [], options = {}) {
+    const
+        log = options.log ?? (() => {}),
+        metaDir = path.resolve(META_DIR);
+
+    if (!fs.existsSync(metaDir)) {
+        log(`adaptfully: meta dir missing at ${metaDir}; skipping credentials`);
         return;
     }
 
-    const deploymentsRoot = path.join(META_DIR, DEPLOYMENTS_DIRNAME);
+    const deploymentsRoot = path.join(metaDir, DEPLOYMENTS_DIRNAME);
 
     if (!fs.existsSync(deploymentsRoot)) {
-        zip.directory(`${META_DIR}/`, 'meta');
+        appendDirectory(zip, metaDir, 'meta');
         return;
     }
 
-    for (const entry of fs.readdirSync(META_DIR, { withFileTypes: true })) {
+    for (const entry of fs.readdirSync(metaDir, { withFileTypes: true })) {
         if (entry.name === DEPLOYMENTS_DIRNAME || entry.name === PUBLISH_DIRNAME) {
             continue;
         }
 
-        const fullPath = path.join(META_DIR, entry.name);
+        const fullPath = path.join(metaDir, entry.name);
         if (entry.isDirectory()) {
-            zip.directory(`${fullPath}/`, `meta/${entry.name}`);
+            appendDirectory(zip, fullPath, `meta/${entry.name}`);
         } else {
             zip.file(fullPath, { name: `meta/${entry.name}` });
         }
     }
 
     if (publishDir && fs.existsSync(publishDir)) {
-        zip.directory(`${publishDir}/`, `meta/${PUBLISH_DIRNAME}`);
+        appendDirectory(zip, publishDir, `meta/${PUBLISH_DIRNAME}`);
+        log(`adaptfully: packaged meta/${PUBLISH_DIRNAME} from ${path.resolve(publishDir)}`);
         return;
     }
 
+    const packaged = [];
+
     for (const deploymentDir of deploymentDirs) {
-        if (!fs.existsSync(deploymentDir)) {
+        const resolved = path.resolve(deploymentDir);
+        if (!fs.existsSync(resolved)) {
+            log(`adaptfully: skipping missing deployment dir ${resolved}`);
             continue;
         }
 
-        const deploymentKey = path.basename(deploymentDir);
-        zip.directory(`${deploymentDir}/`, `meta/${DEPLOYMENTS_DIRNAME}/${deploymentKey}`);
+        const deploymentKey = path.basename(resolved);
+        appendDirectory(zip, resolved, `meta/${DEPLOYMENTS_DIRNAME}/${deploymentKey}`);
+        packaged.push(deploymentKey);
+    }
+
+    if (packaged.length) {
+        log(`adaptfully: packaged deployments: ${packaged.join(', ')}`);
+    } else if (deploymentDirs.length) {
+        log('adaptfully: WARNING no deployment credential folders were packaged');
     }
 }
 
 function createZipStream(deployFolder, contents, options = {}) {
-    const zip = archiver('zip', { zlib: { level: 0 } });
+    const
+        zip = archiver('zip', { zlib: { level: 0 } }),
+        log = options.log ?? console.log;
 
     zip.on('warning', (err) => {
         if (err.code === 'ENOENT') {
@@ -75,11 +116,11 @@ function createZipStream(deployFolder, contents, options = {}) {
         }, { prefix: 'deploy' });
         zip.append(options.indexHtml, { name: 'deploy/index.html' });
     } else {
-        zip.directory(`${deployFolder}/`, 'deploy');
-        zip.file(`${deployFolder}/index.html`, { name: 'deploy/index.html' });
+        appendDirectory(zip, deployFolder, 'deploy');
+        zip.file(path.resolve(deployFolder, 'index.html'), { name: 'deploy/index.html' });
     }
 
-    appendMeta(zip, options.publishDir, options.deploymentDirs);
+    appendMeta(zip, options.publishDir, options.deploymentDirs, { log });
     zip.append(contents, { name: 'package.json' });
     zip.finalize();
 
@@ -91,7 +132,7 @@ function createZipStream(deployFolder, contents, options = {}) {
  *
  * @param {string} deployFolder
  * @param {string} contents
- * @param {{ indexHtml?: string, publishDir?: string, deploymentDirs?: string[] }} [options]
+ * @param {{ indexHtml?: string, publishDir?: string, deploymentDirs?: string[], log?: (message: string) => void }} [options]
  */
 export function createSourceArchive(deployFolder, contents, options = {}) {
     return createZipStream(deployFolder, contents, options);
@@ -110,12 +151,15 @@ export function createArchive(deployFolder, contents, options = {}) {
  * @param {string} artifactPath
  * @param {string} publishDir
  * @param {string} [contents]
+ * @param {{ log?: (message: string) => void }} [options]
  */
-export function createDeployArchive(artifactPath, publishDir, contents) {
-    const zip = archiver('zip', { zlib: { level: 0 } });
+export function createDeployArchive(artifactPath, publishDir, contents, options = {}) {
+    const
+        zip = archiver('zip', { zlib: { level: 0 } }),
+        log = options.log ?? console.log;
 
-    zip.directory(`${artifactPath}/`, false);
-    appendMeta(zip, publishDir);
+    zip.directory(toPosixDir(artifactPath), false);
+    appendMeta(zip, publishDir, [], { log });
 
     if (contents) {
         zip.append(contents, { name: 'package.json' });
@@ -131,7 +175,7 @@ export function createDeployArchive(artifactPath, publishDir, contents) {
  * @param {string} deployFolder
  * @param {string} contents
  * @param {string[]} deploymentDirs
- * @param {{ indexHtml?: string }} [options]
+ * @param {{ indexHtml?: string, log?: (message: string) => void }} [options]
  */
 export function createReleaseArchive(deployFolder, contents, deploymentDirs, options = {}) {
     return createZipStream(deployFolder, contents, {

package/lib/node/artifacts.js

@@ -1,7 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-const MANIFEST_NAME = 'wrapfully-build.json';
+const
+    MANIFEST_NAME = 'wrapfully-build.json',
+    STATUS_NAME = 'wrapfully-status.json';
 
 /**
  * Directory where build responses are extracted (contains wrapfully-build.json).
@@ -14,6 +16,25 @@ export function buildOutputDir(pkg, outputRoot = 'output') {
     return path.resolve(outputFolder);
 }
 
+/**
+ * Remove prior Wrapfully extract artifacts so zip responses do not stack
+ * nested `artifacts/` directories across runs.
+ *
+ * @param {string} [outputRoot='output']
+ */
+export function clearStaleBuildExtract(outputRoot = 'output') {
+    const root = path.resolve(outputRoot);
+    const stalePaths = [
+        path.join(root, 'artifacts'),
+        path.join(root, MANIFEST_NAME),
+        path.join(root, STATUS_NAME),
+    ];
+
+    for (const stalePath of stalePaths) {
+        fs.rmSync(stalePath, { recursive: true, force: true });
+    }
+}
+
 /**
  * Resolve the artifact directory from a prior `adaptfully build` (or compatible zip extract).
  *

package/lib/node/deploy.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import unzipper from 'unzip-stream';
 import { createDeployArchive, createReleaseArchive, createSourceArchive } from './archive.js';
+import { clearStaleBuildExtract } from './artifacts.js';
 import { listHtmlFilesRecursive } from './fs-utils.js';
 import { printBuildReport } from './report.js';
 
@@ -47,9 +48,15 @@ function resolveWrapfullyUrl(server, stage, family, gameId, platformKey, deploym
 export async function send(gameId, contents, server, stage, family, deployFolder, pkg, mode = 'extract', options = {}) {
     const log = options.log ?? console.log;
     const platformKey = options.platformKey ?? family;
+    const outputRoot = pkg.config?.outputFolder || 'output';
+
+    if (mode === 'extract') {
+        clearStaleBuildExtract(outputRoot);
+    }
+
     const destination = mode === 'extract'
-        ? unzipper.Extract({ path: './output/', concurrency: 1 })
-        : fs.createWriteStream(`./output/${pkg.name}-${pkg.version}-${stage}-${family}.zip`);
+        ? unzipper.Extract({ path: `${outputRoot}/`, concurrency: 1 })
+        : fs.createWriteStream(`${outputRoot}/${pkg.name}-${pkg.version}-${stage}-${family}.zip`);
 
     let archiveStream;
 
@@ -60,11 +67,11 @@ export async function send(gameId, contents, server, stage, family, deployFolder
         if (!options.deploymentKey) {
             throw new Error('deploy stage requires options.deploymentKey');
         }
-        archiveStream = createDeployArchive(options.artifactPath, options.publishDir, contents);
+        archiveStream = createDeployArchive(options.artifactPath, options.publishDir, contents, { log });
     } else if (stage === 'release') {
-        archiveStream = createReleaseArchive(deployFolder, contents, options.deploymentDirs ?? []);
+        archiveStream = createReleaseArchive(deployFolder, contents, options.deploymentDirs ?? [], { log });
     } else {
-        archiveStream = createSourceArchive(deployFolder, contents);
+        archiveStream = createSourceArchive(deployFolder, contents, { log });
     }
 
     const url = resolveWrapfullyUrl(server, stage, family, gameId, platformKey, options.deploymentKey);

package/lib/node/index.js

@@ -1,4 +1,4 @@
-export { buildOutputDir, resolveBuildArtifactDir } from './artifacts.js';
+export { buildOutputDir, clearStaleBuildExtract, resolveBuildArtifactDir } from './artifacts.js';
 export { createArchive, createDeployArchive, createReleaseArchive, createSourceArchive } from './archive.js';
 export { loadProjectConfig, resolveServerUrl } from './config.js';
 export { send } from './deploy.js';

package/lib/node/pipeline.js

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import { loadProjectConfig, resolveServerUrl } from './config.js';
 import { send } from './deploy.js';
 import { resolveBuildArtifactDir } from './artifacts.js';
@@ -73,6 +74,12 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
 
         log(`adaptfully: ${stage} ${platformKey} → ${buildSpec.family} (${buildSpec.targets.join(', ')})`);
 
+        log(
+            `adaptfully: release deployments → ${
+                deploymentDirs.map((dir) => path.resolve(dir)).join(', ') || '(none)'
+            }`,
+        );
+
         await send(
             gameId,
             contents,
@@ -85,7 +92,7 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
             {
                 log,
                 platformKey,
-                deploymentDirs,
+                deploymentDirs: deploymentDirs.map((dir) => path.resolve(dir)),
             },
         );
 

package/package.json

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