@makefully/adaptfully 3.7.1 → 3.8.1

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project are documented in this file.
 
+## 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
+
+- **`steam-auth` Steamworks app ID** moves from top-level `config.steamId` to **`platforms.<name>.steamId`**. Steam **upload** app IDs belong in each deployment’s `manifest.json` (Wrapfully), not in Adaptfully client config.
+
 ## 3.7.0 — 2026-07-09
 
 ### Added

package/README.md

@@ -32,8 +32,8 @@ adaptfully steam-auth                         # one-time: log in with steamcmd
 | Stage | What it does |
 |-------|----------------|
 | `prebuild` | Copy `deploy/` to `output/<platform>-prebuild/` and inject registrations into `config.htmlInjections` |
-| `build` | Prebuild, then POST the result to Wrapfully (the platform's default/first deployment only) |
-| `deploy` | Prebuild, zip, POST to Wrapfully once per deployment; platform release when credentials are in the deployment folder |
+| `build` | Prebuild, then POST the result to Wrapfully (artifact zip only) |
+| `deploy` | POST the prior build artifact from `./output/` to each configured deployment (or `--deployment`) |
 | `steam-auth` | One-time local setup: install steamcmd, interactive login, write the `steam` deployment's `steam.json` |
 
 `wrapfully-deploy` is a compatibility alias for `adaptfully deploy` when invoked with a Wrapfully builder name (`steam`, `win`, `android`, etc.).
@@ -135,12 +135,11 @@ Each platform entry may set a **`packager`** (`web`, `electron`, `cordova`, or `
 | `cordova` | `cordova.js` stub, `game-config.js`, CSP/viewport HTML extras |
 | `capacitor` | `game-config.js` (more Capacitor-specific output planned) |
 
-**`steam-auth` requires `packager: "electron"`** and `config.steamId`.
+**`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.
 
 ```json
 {
   "config": {
-    "steamId": 719140,
     "platforms": {
       "web": {
         "packager": "web",
@@ -148,6 +147,7 @@ Each platform entry may set a **`packager`** (`web`, `electron`, `cordova`, or `
       },
       "steam": {
         "packager": "electron",
+        "steamId": 1234567,
         "registrations": { "auth": "steam-auth" }
       }
     }
@@ -160,7 +160,7 @@ Each platform entry may set a **`packager`** (`web`, `electron`, `cordova`, or `
 When `steam-auth` is registered on an **`electron`** platform, Adaptfully prebuild writes:
 
 - **`main.js`** — Electron shell with Steam overlay enabled and a preload script wired in
-- **`preload.js`** — initializes [steamworks.js](https://github.com/ceifa/steamworks.js) with `config.steamId` and exposes `window.__ADAPTFULLY_STEAMWORKS__`
+- **`preload.js`** — initializes [steamworks.js](https://github.com/ceifa/steamworks.js) with `platforms.<name>.steamId` and exposes `window.__ADAPTFULLY_STEAMWORKS__`
 
 The renderer `steam-auth` plugin reads the Steam ID from that bridge. When Steam is available, `autoLogin()` succeeds immediately with `{ id: steamId64, email: '' }`. Optional config keys:
 
@@ -371,7 +371,6 @@ Standard npm fields (`name`, `version`, `description`) are used directly. Add a
     "scope": "https://example.com/games/",
     "themeColor": "#1a1a2e",
     "twitterId": "@examplegames",
-    "steamId": 1234567,
     "deployFolder": "deploy",
     "platforms": {
       "web": {
@@ -382,6 +381,7 @@ Standard npm fields (`name`, `version`, `description`) are used directly. Add a
       },
       "steam": {
         "packager": "electron",
+        "steamId": 1234567,
         "registrations": {
           "auth": "steam-auth",
           "storage": "javascript/adaptfully-bridge.js"
@@ -407,7 +407,6 @@ Standard npm fields (`name`, `version`, `description`) are used directly. Add a
 | `scope` | Web/PWA | Base URL scope for the web app |
 | `themeColor` | Cordova, Electron, UWP, web | Loading screen / theme color |
 | `twitterId` | Web | Twitter handle for meta tags |
-| `steamId` | Steam | Steam app ID |
 | `deployFolder` | Client | Neutral deploy directory staged before prebuild (default: `deploy`) |
 | `htmlInjections` | Prebuild | Deploy-relative HTML paths to inject (default: `["index.html"]`) |
 | `outputFolder` | Client | Prebuild output root (default: `output`) |
@@ -415,6 +414,7 @@ Standard npm fields (`name`, `version`, `description`) are used directly. Add a
 | `platforms.<name>.builder` | Build/deploy | Override Wrapfully builder for a platform (default: `web` → `webapp`, others match platform key) |
 | `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` |
 | `properties` | Cordova | Cordova config.xml entries (plugins, allow-navigation, etc.) |
 
 ### `wrapfully.json`
@@ -568,7 +568,7 @@ Accounts **without** Steam Guard only need `username`, `password`, and `configVd
 
 Re-run `adaptfully steam-auth` if Steam invalidates the token (new machine, password change, or expired guard).
 
-Also set `steamId` in your `config` block.
+For Steamworks / `steam-auth` client builds, set `platforms.<name>.steamId`. For Steam **uploads**, set `steamId` on the deployment’s `manifest.json` (see Wrapfully). Those are independent: you can deploy without steam-auth, or use steam-auth without uploading.
 
 Steam builds can run on either the Windows or Mac server. The server that receives the request builds its own platforms and requests the rest from the other server (Windows builds `win` and requests `mac`/`linux`; Mac builds `mac`/`linux` and requests `win`). Install the Steamworks SDK ContentBuilder on any server that will upload to Steam.
 

package/lib/node/artifacts.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const MANIFEST_NAME = 'wrapfully-build.json';
+const STATUS_NAME = 'wrapfully-status.json';
+
+/**
+ * Directory where build responses are extracted (contains wrapfully-build.json).
+ *
+ * @param {{ config?: { outputFolder?: string } }} pkg
+ * @param {string} [outputRoot='output']
+ */
+export function buildOutputDir(pkg, outputRoot = 'output') {
+    const outputFolder = pkg.config?.outputFolder || outputRoot;
+    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).
+ *
+ * @param {{ name: string, version: string, config?: { outputFolder?: string } }} pkg
+ * @param {{ outputRoot?: string, platformKey?: string }} [options]
+ * @returns {string}
+ */
+export function resolveBuildArtifactDir(pkg, options = {}) {
+    const artifactDir = buildOutputDir(pkg, options.outputRoot);
+    const manifestPath = path.join(artifactDir, MANIFEST_NAME);
+
+    if (!fs.existsSync(manifestPath)) {
+        throw new Error(
+            'No prior build artifact found in '
+            + `${artifactDir}. Run \`adaptfully build <platform>\` first or pass --artifact <path>.`,
+        );
+    }
+
+    let manifest;
+    try {
+        manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    } catch {
+        throw new Error(`Unable to read ${manifestPath}`);
+    }
+
+    const gameId = `${pkg.name}-${pkg.version}`;
+    if (manifest.gameId && manifest.gameId !== gameId) {
+        throw new Error(
+            `Build artifact is for "${manifest.gameId}" but package.json is ${gameId}. `
+            + 'Run a fresh build or pass --artifact <path>.',
+        );
+    }
+
+    if (options.platformKey && manifest.platformKey && manifest.platformKey !== options.platformKey) {
+        throw new Error(
+            `Build artifact is for platform "${manifest.platformKey}" but deploy targets "${options.platformKey}". `
+            + 'Run a fresh build or pass --artifact <path>.',
+        );
+    }
+
+    return artifactDir;
+}

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;
 

package/lib/node/index.js

@@ -1,3 +1,4 @@
+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/packagers/electron.js

@@ -178,6 +178,19 @@ export function buildElectronPreload(steamAppId) {
     return ELECTRON_PRELOAD_HEAD + steamAppId + ELECTRON_PRELOAD_TAIL;
 }
 
+/**
+ * Steamworks app ID for steam-auth preload, from the active platform config.
+ * @param {string | null | undefined} platformKey
+ * @param {{ config?: { platforms?: Record<string, { steamId?: number | string }> } }} pkg
+ * @returns {number | string | undefined}
+ */
+export function resolvePlatformSteamId(platformKey, pkg) {
+    if (!platformKey) {
+        return undefined;
+    }
+    return pkg.config?.platforms?.[platformKey]?.steamId;
+}
+
 export class ElectronPackager extends Packager {
     /** @type {'electron'} */
     static id = 'electron';
@@ -188,10 +201,10 @@ export class ElectronPackager extends Packager {
     validate() {
         super.validate();
 
-        if (this.usesPlugin('steam-auth') && !this.pkg.config?.steamId) {
+        if (this.usesPlugin('steam-auth') && !resolvePlatformSteamId(this.platformKey, this.pkg)) {
             const platformLabel = this.platformKey ?? this.platforms.join(', ');
             throw new Error(
-                `Platform "${platformLabel}" uses steam-auth but config.steamId is not set.`,
+                `Platform "${platformLabel}" uses steam-auth but platforms.${platformLabel}.steamId is not set.`,
             );
         }
     }
@@ -212,9 +225,10 @@ export class ElectronPackager extends Packager {
         const mainContent = buildElectronMain(withSteam, this.pkg.config?.themeColor);
 
         if (withSteam) {
+            const steamId = resolvePlatformSteamId(this.platformKey, this.pkg);
             fs.writeFileSync(
                 path.join(dest, 'preload.js'),
-                buildElectronPreload(this.pkg.config.steamId),
+                buildElectronPreload(steamId),
             );
             this.log('adaptfully: write preload.js (steam-auth)');
         }

package/lib/node/packagers/index.js

@@ -6,7 +6,12 @@ import { WebPackager } from './web.js';
 
 export { Packager, VALID_PACKAGERS } from './base.js';
 export { WebPackager } from './web.js';
-export { ElectronPackager, buildElectronMain, buildElectronPreload } from './electron.js';
+export {
+    ElectronPackager,
+    buildElectronMain,
+    buildElectronPreload,
+    resolvePlatformSteamId,
+} from './electron.js';
 export { CordovaPackager } from './cordova.js';
 export { CapacitorPackager } from './capacitor.js';
 
@@ -22,7 +27,7 @@ const PACKAGER_REGISTRY = {
 
 /**
  * @param {string} platformKey
- * @param {{ config?: { platforms?: Record<string, { packager?: string, registrations?: Record<string, string> }>, steamId?: number } }} pkg
+ * @param {{ config?: { platforms?: Record<string, { packager?: string, registrations?: Record<string, string>, steamId?: number | string }> } }} pkg
  * @param {{ log?: (message: string) => void, platforms?: string[] }} [options]
  * @returns {Packager}
  */
@@ -54,7 +59,7 @@ export function resolvePlatformPackager(platformKey, pkg) {
 
 /**
  * @param {string} platformKey
- * @param {{ config?: { platforms?: Record<string, { packager?: string, registrations?: Record<string, string> }>, steamId?: number } }} pkg
+ * @param {{ config?: { platforms?: Record<string, { packager?: string, registrations?: Record<string, string>, steamId?: number | string }> } }} pkg
  */
 export function validatePlatformPackager(platformKey, pkg) {
     createPackagerForPlatform(platformKey, pkg).validate();
@@ -70,7 +75,7 @@ export function usesSteamAuth(registrations) {
 /**
  * @param {string} dest
  * @param {string} platformKey
- * @param {{ config?: { platforms?: Record<string, { packager?: string, registrations?: Record<string, string> }>, steamId?: number } }} pkg
+ * @param {{ config?: { platforms?: Record<string, { packager?: string, registrations?: Record<string, string>, steamId?: number | string }> } }} pkg
  * @param {{ log?: (message: string) => void, platforms?: string[] }} [options]
  */
 export function applyPackagerTemplates(dest, platformKey, pkg, options = {}) {

package/lib/node/pipeline.js

@@ -1,5 +1,6 @@
 import { loadProjectConfig, resolveServerUrl } from './config.js';
 import { send } from './deploy.js';
+import { resolveBuildArtifactDir } from './artifacts.js';
 import { prebuildPlatform } from './prebuild.js';
 import {
     resolveBuildSpec,
@@ -43,8 +44,16 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
         deployments = deployments.filter((key) => key !== 'zip');
     }
 
-    const prebuiltDir = stage === 'deploy' && options.artifactPath
-        ? options.artifactPath
+    let artifactPath = options.artifactPath;
+    if (stage === 'deploy' && !artifactPath) {
+        artifactPath = resolveBuildArtifactDir(pkg, {
+            outputRoot: options.outputRoot,
+            platformKey,
+        });
+    }
+
+    const prebuiltDir = stage === 'deploy'
+        ? artifactPath
         : prebuildPlatform(deployFolder, platformKey, pkg, {
             log,
             outputRoot: options.outputRoot,
@@ -81,7 +90,7 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
         );
 
         sent.push({ deploymentKey: 'release', stage, family: buildSpec.family });
-        return { prebuiltDir, platformKey, buildSpec, deployments: sent };
+        return { prebuiltDir, platformKey, buildSpec, deployments: sent, artifactPath };
     }
 
     for (const deploymentKey of deployments) {
@@ -108,14 +117,14 @@ export async function runAdaptfullyStage(stage, platformKey, options) {
                 publishDir,
                 platformKey,
                 deploymentKey: wrapStage === 'deploy' ? deploymentKey : undefined,
-                artifactPath: options.artifactPath,
+                artifactPath,
             },
         );
 
         sent.push({ deploymentKey, stage: wrapStage, family: buildSpec.family });
     }
 
-    return { prebuiltDir, platformKey, buildSpec, deployments: sent };
+    return { prebuiltDir, platformKey, buildSpec, deployments: sent, artifactPath };
 }
 
 /**
@@ -147,7 +156,7 @@ export async function adaptfullyFromCli(argv = process.argv) {
             + '  release   prebuild + POST /{family}/release (build + configured deployments)\n'
             + '\n'
             + '  --deployment <key>  Target a single named deployment.\n'
-            + '  --artifact <path>   Prior build artifact directory (deploy stage).\n'
+            + '  --artifact <path>   Prior build artifact directory (deploy only; default: ./output/ after build).\n'
             + '\n'
             + '  steam-auth  Install steamcmd if needed, log in interactively, write steam deployment steam.json',
         );

package/package.json

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