@makefully/adaptfully 4.0.0 → 4.1.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project are documented in this file.
 
+## 4.1.0 — 2026-09-04
+
+### Added
+
+- **`adaptfully android-keystore`** — Generate debug/release keystores with `keytool` and write `assets/meta/deployments/android/build.json`.
+- **`adaptfully apple-signing`** — Generate CSR/key (OpenSSL), export `.p12` from an Apple `.cer`, place provisioning profiles under `ios/apple/`, optional `apple.p12Password` in `build.json`.
+- **Credential setup guides** — First-time walkthroughs under [`docs/credentials/`](docs/credentials/README.md) for iOS, Android, and Steam (full manual steps + helper skip markers).
+
 ## 4.0.0 — 2026-09-03
 
 ### Removed

package/README.md

@@ -29,6 +29,8 @@ adaptfully deploy steam                       # prebuild + POST to Wrapfully ste
 adaptfully steam-publish                      # one-time: log in with steamcmd → assets/meta/deployments/steam/steam.json
 adaptfully google-publish --from ./sa.json    # one-time: import Play service account → deployments/android/google.json
 adaptfully apple-publish                      # one-time: write App Store Connect creds → deployments/ios/apple.json
+adaptfully android-keystore                   # one-time: generate keystores + android build.json
+adaptfully apple-signing                      # one-time: CSR / .p12 / provisioning files under ios/apple/
 ```
 
 | Stage | What it does |
@@ -39,6 +41,10 @@ adaptfully apple-publish                      # one-time: write App Store Connec
 | `steam-publish` | One-time local setup: install steamcmd, interactive login, write the `steam` deployment's `steam.json` (also updates `.gitignore`) |
 | `google-publish` | One-time local setup: import a Play Console service-account JSON into the `android` deployment folder (also updates `.gitignore`) |
 | `apple-publish` | One-time local setup: write App Store Connect credentials into the `ios` deployment folder (also updates `.gitignore`) |
+| `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`) |
+
+First-time walkthroughs (manual steps + helper skip markers): [docs/credentials/](docs/credentials/README.md).
 
 `wrapfully-deploy` is a compatibility alias for `adaptfully deploy` when invoked with a Wrapfully builder name (`steam`, `win`, `android`, etc.).
 
@@ -547,10 +553,14 @@ For a single platform, pass the specific builder name.
 
 ### Platform package requirements
 
+**First-time setup:** see [docs/credentials/](docs/credentials/README.md) for iOS, Android, and Steam walkthroughs (CLI helpers + full manual steps).
+
 Signing keys, provisioning profiles, and store credentials go in the deployment folder `./assets/meta/deployments/<deployment>/` on disk (the selected deployment is sent as `meta/publish/` in the zip). The examples below use `<deployment>` as a placeholder for the target key (e.g. `steam`, `web-prod`). **These files contain secrets** — add them to `.gitignore` and never commit them to a public repository. (Projects that have not adopted the `deployments/` layout may still place these under the legacy `./assets/meta/publish/`.)
 
 #### Android (`android`, `android-dev`)
 
+First-time setup: [docs/credentials/android.md](docs/credentials/android.md) (`android-keystore`, `google-publish`).
+
 Place keystore files in `assets/meta/deployments/<deployment>/android/`. Include `assets/meta/deployments/<deployment>/build.json`:
 
 ```json
@@ -602,6 +612,8 @@ The file looks like:
 
 #### Apple (`ios`, `ios-dev`, `ios-sim`, `mac`)
 
+First-time setup: [docs/credentials/ios.md](docs/credentials/ios.md) (`apple-signing`, `apple-publish`).
+
 **Capacitor iOS** signing is file-based under the deployment folder:
 
 ```
@@ -614,7 +626,7 @@ assets/meta/deployments/<deployment>/
   build.json                          # optional: { "apple": { "p12Password": "..." } }
 ```
 
-`adaptfully build` (zip-only) still packages this deployment folder for Capacitor so device debug builds can sign. Optional `build.json` may set `apple.p12Password` for the `.p12` passphrase (Wrapfully uses an ephemeral keychain per build). Team ID and profile UUID are read from the `.mobileprovision`. Enable **Sign in with Apple** on the App ID when using Capgo Apple auth.
+`adaptfully build` (zip-only) still packages this deployment folder for Capacitor so device debug builds can sign. Optional `build.json` may set `apple.p12Password` for the `.p12` passphrase (defaults to empty when omitted). Team ID and profile UUID are read from the `.mobileprovision`. Enable **Sign in with Apple** on the App ID when using Capgo Apple auth.
 
 To deploy to the App Store, include `assets/meta/deployments/<deployment>/apple.json`. The easiest path is:
 
@@ -638,6 +650,8 @@ iOS IPA upload uses `username` + `password` via `xcrun altool --upload-app`. `ca
 
 #### Steam (`steam`, `steam-dev`)
 
+First-time setup: [docs/credentials/steam.md](docs/credentials/steam.md) (`steam-publish`).
+
 `steam-dev` builds debug Electron binaries for Windows, Mac, and Linux without uploading to Steam. No `steam.json` credentials are required.
 
 For release uploads, run **`adaptfully steam-publish`** once on your machine. It installs steamcmd if needed, logs you in interactively (enter a Steam Guard code if prompted), and writes `assets/meta/deployments/steam/steam.json`:

package/docs/credentials/README.md

@@ -0,0 +1,50 @@
+# Credential setup guides
+
+One-time local setup for signing and store-upload credentials under
+`assets/meta/deployments/<deployment>/`.
+
+These guides stay focused on **files in your game repo** and Adaptfully CLI helpers.
+They do not cover which OS builds the artifact.
+
+## Guides
+
+| Platform | Guide | Typical deployment folder |
+|----------|--------|---------------------------|
+| iOS | [ios.md](./ios.md) | `assets/meta/deployments/ios/` |
+| Android | [android.md](./android.md) | `assets/meta/deployments/android/` |
+| Steam | [steam.md](./steam.md) | `assets/meta/deployments/steam/` |
+
+## Helpers
+
+| Command | Writes |
+|---------|--------|
+| `npx adaptfully android-keystore` | `android/*.keystore` + `build.json` |
+| `npx adaptfully google-publish --from <sa.json>` | `google.json` |
+| `npx adaptfully apple-signing` | CSR/key work files, `apple/*.p12`, optional `.mobileprovision` + `build.json` `apple.p12Password` |
+| `npx adaptfully apple-publish` | `apple.json` (App Store Connect upload login) |
+| `npx adaptfully steam-publish` | `steam.json` |
+
+Each guide lists the **full manual process** and marks **Helper** steps with **skip to step N** when you use a command instead.
+
+## Debug vs release
+
+| Goal | Credentials needed? |
+|------|---------------------|
+| `android-dev` / local debug APK | Project debug keystore (recommended) or host default |
+| `android` Play release | Release keystore + `google.json` |
+| `ios-dev` device IPA | `development.p12` + `development.mobileprovision` |
+| `ios` App Store | `distribution.p12` + `app-store.mobileprovision` + `apple.json` |
+| `ios-sim` | No device signing files |
+| `steam-dev` | None |
+| `steam` upload | `steam.json` |
+
+## Secrets
+
+Do not commit credential files. Helpers update `.gitignore` with Adaptfully patterns such as:
+
+- `assets/meta/deployments/**/build.json`
+- `assets/meta/deployments/**/google.json`
+- `assets/meta/deployments/**/apple.json`
+- `assets/meta/deployments/**/steam.json`
+- `assets/meta/deployments/**/android/`
+- `assets/meta/deployments/**/apple/`

package/docs/credentials/android.md

@@ -0,0 +1,124 @@
+# Android credentials
+
+Set up signing keystores and (for Play uploads) a Google Play service account.
+
+**Default folder:** `assets/meta/deployments/android/`
+
+## Recommended path
+
+1. **Helper:** `npx adaptfully android-keystore` — creates debug + release keystores and `build.json`.
+2. In Google Play Console, create a service account and download its JSON key (manual).
+3. **Helper:** `npx adaptfully google-publish --from ./path/to/sa.json` — writes `google.json`.
+
+Debug-only: `npx adaptfully android-keystore --debug-only`.
+
+## What you need
+
+| Goal | Files |
+|------|--------|
+| Debug / `android-dev` | `android/debug.keystore` + `build.json` `android.debug` block |
+| Play release / `android` | `android/release.keystore` + `build.json` `android.release` + `google.json` |
+
+`build.json` keystore paths are relative to the deployment folder (the directory that contains `build.json`).
+
+## Full steps
+
+### 1. Prerequisites
+
+- JDK on PATH so `keytool` works (`keytool -help`).
+- A Play Console app (for release uploads).
+
+### 2. Helper: generate keystores
+
+**Helper:** `npx adaptfully android-keystore [--deployment android] [--debug-only] [--yes]`
+
+If you run this, **skip to step 5** (Play service account). For debug-only, you can stop after this step.
+
+Flags:
+
+- `--debug-only` — only the debug keystore + `build.json` debug block
+- `--yes` — overwrite existing `build.json` without prompting
+- `--alias`, `--store-password`, `--key-password`, `--cn` — non-interactive release keystore fields
+
+### 3. Manual alternative: create keystores with keytool
+
+Skip this if you used step 2.
+
+```bash
+mkdir -p assets/meta/deployments/android/android
+
+keytool -genkeypair -v \
+  -keystore assets/meta/deployments/android/android/debug.keystore \
+  -alias androiddebugkey -keyalg RSA -keysize 2048 -validity 10000 \
+  -storepass android -keypass android \
+  -dname "CN=Android Debug,O=Android,C=US"
+
+keytool -genkeypair -v \
+  -keystore assets/meta/deployments/android/android/release.keystore \
+  -alias upload -keyalg RSA -keysize 2048 -validity 10000 \
+  -storepass "(your store password)" -keypass "(your key password)" \
+  -dname "CN=Your Studio,O=Your Studio,C=US"
+```
+
+### 4. Manual alternative: write `build.json`
+
+Skip this if you used step 2.
+
+Create `assets/meta/deployments/android/build.json`:
+
+```json
+{
+  "android": {
+    "debug": {
+      "keystore": "./android/debug.keystore",
+      "packageType": "apk",
+      "storePassword": "android",
+      "alias": "androiddebugkey",
+      "password": "android",
+      "keystoreType": ""
+    },
+    "release": {
+      "keystore": "./android/release.keystore",
+      "packageType": "bundle",
+      "storePassword": "(your store password)",
+      "alias": "upload",
+      "password": "(your key password)",
+      "keystoreType": ""
+    }
+  }
+}
+```
+
+### 5. Create a Play Console service account (manual)
+
+Required only for Play uploads (`adaptfully release android` / deploy to Google).
+
+1. Open [Google Play Console](https://play.google.com/console/) → **Setup** → **API access** (or Google Cloud IAM linked to the Play developer account).
+2. Create or select a service account with permission to manage releases.
+3. Download a JSON key for that service account.
+4. Invite the service account email in Play Console with the right app permissions.
+
+### 6. Helper: import `google.json`
+
+**Helper:** `npx adaptfully google-publish --from ./path/to/service-account.json [--deployment android]`
+
+If you run this, **skip to step 8**.
+
+### 7. Manual alternative: copy the service account JSON
+
+Skip this if you used step 6.
+
+Copy the downloaded key to `assets/meta/deployments/android/google.json`. Ensure `manifest.json` includes `"type": "google"` (helpers write this for you).
+
+### 8. Done when
+
+- [ ] `build.json` exists with debug (and release, if shipping)
+- [ ] Keystore files exist at the paths listed in `build.json`
+- [ ] For Play uploads: `google.json` is present and the service account can access the app
+- [ ] Credential paths are gitignored
+
+## Notes
+
+- Prefer **project-owned** keystores so debug installs stay reproducible across machines.
+- Some build hosts supply a default debug keystore when `build.json` is missing; do not rely on that for shared projects.
+- Keep release keystore passwords offline; losing the release keystore can block Play updates for that signing key.

package/docs/credentials/ios.md

@@ -0,0 +1,182 @@
+# iOS credentials
+
+Set up Apple signing files and (for App Store uploads) App Store Connect login credentials.
+
+**Default folder:** `assets/meta/deployments/ios/`
+
+You can create signing material on **macOS or Windows**. The sections below branch where the local tools differ.
+
+## Recommended path
+
+1. **Helper:** `npx adaptfully apple-signing --kind development` (and/or `--kind distribution`) — generates a CSR, walks portal checklist, exports `.p12`, optionally copies the provisioning profile.
+2. Complete the Apple Developer portal steps the helper prints (upload CSR, download `.cer` / `.mobileprovision`).
+3. For App Store uploads only — **Helper:** `npx adaptfully apple-publish` — writes `apple.json`.
+
+Simulator builds (`ios-sim`) need no device signing files.
+
+## What you need
+
+| Goal | Files |
+|------|--------|
+| Device debug (`ios-dev`) | `apple/development.p12`, `apple/development.mobileprovision` |
+| App Store (`ios` release) | `apple/distribution.p12`, `apple/app-store.mobileprovision`, `apple.json` |
+| Simulator (`ios-sim`) | None |
+
+Optional `build.json` next to `apple/`:
+
+```json
+{
+  "apple": {
+    "p12Password": "(passphrase used when exporting the .p12)"
+  }
+}
+```
+
+If omitted, the build pipeline treats the passphrase as empty.
+
+## Prerequisites
+
+- Apple Developer Program membership.
+- An App ID matching your platform `packageName`.
+- If you use Capgo Apple social login: enable **Sign in with Apple** on that App ID.
+- For development profiles: registered device UDIDs.
+- OpenSSL on PATH for the helper / Windows manual path (`openssl version`). macOS Keychain users can still use the helper if OpenSSL is available (e.g. via Homebrew or Xcode CLT tooling).
+
+## Full steps
+
+### 1. Helper: CSR, `.p12`, and profile placement
+
+**Helper:** `npx adaptfully apple-signing [--kind development|distribution] [--csr-only] [--from-cer path] [--provision path] [--p12-password secret]`
+
+If you run the full interactive helper (not `--csr-only`), **skip to step 7** after it finishes (or step 8 for App Store Connect login).
+
+Useful flags:
+
+- `--csr-only` — stop after writing the CSR; later continue with `--from-cer`
+- `--from-cer ./Certificates.cer` — skip CSR generation when `apple/.work/private.key` already exists
+- `--provision ./Profile.mobileprovision` — copy/rename into `apple/`
+- `--kind development` or `--kind distribution`
+
+Work files live under `assets/meta/deployments/ios/apple/.work/` by default (`private.key` + CSR).
+
+### 2. Create a Certificate Signing Request (manual)
+
+Skip this if you used step 1 (or will use `--from-cer` with an existing key from step 1).
+
+#### macOS (Keychain Access)
+
+1. Open **Keychain Access** → **Certificate Assistant** → **Request a Certificate From a Certificate Authority…**
+2. Enter your email and common name; choose **Saved to disk**.
+3. Save the `.certSigningRequest` file.
+
+#### Windows / OpenSSL (any OS)
+
+```bash
+mkdir -p assets/meta/deployments/ios/apple/.work
+cd assets/meta/deployments/ios/apple/.work
+
+openssl genrsa -out private.key 2048
+openssl req -new -key private.key -out CertificateSigningRequest.certSigningRequest -subj "/emailAddress=you@example.com/CN=Your Name/C=US"
+```
+
+### 3. Create the certificate on the Apple Developer site (manual)
+
+Always required — Apple must issue the certificate.
+
+1. Open [Certificates](https://developer.apple.com/account/resources/certificates/list).
+2. Create **Apple Development** (device debug) and/or **Apple Distribution** (App Store).
+3. Upload the CSR from step 1 or 2.
+4. Download the `.cer` file.
+
+### 4. Export a `.p12` (manual)
+
+Skip this if step 1 already exported `development.p12` / `distribution.p12`.
+
+#### macOS (Keychain Access)
+
+1. Double-click the `.cer` to import it into Keychain Access.
+2. Find the certificate (and its private key) → **Export…** → `.p12`.
+3. Choose a passphrase; remember it for `build.json` `apple.p12Password`.
+4. Save as `assets/meta/deployments/ios/apple/development.p12` or `distribution.p12`.
+
+#### Windows / OpenSSL
+
+```bash
+# From the folder that has private.key and the downloaded .cer
+openssl x509 -in Certificates.cer -inform DER -out cert.pem -outform PEM
+openssl pkcs12 -export -inkey private.key -in cert.pem -out development.p12
+# or distribution.p12 — use the matching kind
+```
+
+Move the `.p12` to `assets/meta/deployments/ios/apple/`.
+
+If DER conversion fails, try importing the `.cer` as PEM directly in the `pkcs12 -export` `-in` argument.
+
+### 5. Create and download a provisioning profile (manual)
+
+Always required for device / App Store signing.
+
+1. Register devices (development) under [Devices](https://developer.apple.com/account/resources/devices/list).
+2. Open [Profiles](https://developer.apple.com/account/resources/profiles/list).
+3. Create a **Development** profile or **App Store** profile for your App ID and certificate.
+4. Download the `.mobileprovision`.
+
+### 6. Place the provisioning profile (manual)
+
+Skip this if step 1 copied it with `--provision`.
+
+Rename/copy to:
+
+- Development → `assets/meta/deployments/ios/apple/development.mobileprovision`
+- App Store → `assets/meta/deployments/ios/apple/app-store.mobileprovision`
+
+### 7. Optional: record the `.p12` passphrase
+
+Skip this if `apple-signing` already wrote `build.json`.
+
+Create or merge `assets/meta/deployments/ios/build.json`:
+
+```json
+{
+  "apple": {
+    "p12Password": "(your .p12 passphrase)"
+  }
+}
+```
+
+### 8. Helper: App Store Connect login (`apple.json`)
+
+Required only for App Store uploads.
+
+**Helper:** `npx adaptfully apple-publish [--deployment ios]`
+
+If you run this, **skip to step 10**.
+
+You need an [app-specific password](https://appleid.apple.com/) for your Apple ID.
+
+### 9. Manual alternative: write `apple.json`
+
+Skip this if you used step 8.
+
+```json
+{
+  "category": "public.app-category.games",
+  "identity": "(your team id)",
+  "username": "(Apple ID email)",
+  "password": "(app-specific password)"
+}
+```
+
+### 10. Done when
+
+- [ ] For `ios-dev`: `apple/development.p12` + `apple/development.mobileprovision`
+- [ ] For App Store: `apple/distribution.p12` + `apple/app-store.mobileprovision` + `apple.json`
+- [ ] `apple.p12Password` matches the `.p12` passphrase when the passphrase is non-empty
+- [ ] App ID matches `packageName`; Sign in with Apple enabled if you use Capgo Apple auth
+- [ ] Credential paths are gitignored
+
+## Notes
+
+- Filenames under `apple/` must match the table above.
+- You can create credentials on Windows even if the IPA is built elsewhere.
+- Re-run `apple-signing --kind …` separately for development and distribution when you need both.

package/docs/credentials/steam.md

@@ -0,0 +1,99 @@
+# Steam credentials
+
+Set up Steamworks upload login for release deploys. Debug Steam builds need no upload credentials.
+
+**Default folder:** `assets/meta/deployments/steam/`
+
+## Recommended path
+
+1. Create or choose a Steamworks **build account** (manual; prefer a dedicated publisher account).
+2. **Helper:** `npx adaptfully steam-publish` — installs steamcmd if needed, logs in interactively, writes `steam.json`.
+3. Set upload `steamId` on the deployment `manifest.json` (and client `platforms.*.steamId` if you use Steamworks auth).
+
+## What you need
+
+| Goal | Files |
+|------|--------|
+| `steam-dev` (local Electron debug) | None |
+| `steam` release upload | `steam.json` (+ `manifest.json` with upload `steamId`) |
+
+## Full steps
+
+### 1. Prerequisites
+
+- A Steamworks partner app.
+- A Steam account allowed to upload builds (Steam Guard may be enabled).
+
+### 2. Helper: write `steam.json`
+
+**Helper:** `npx adaptfully steam-publish [--username U] [--password P] [--deployment steam]`
+
+If you run this, **skip to step 6**.
+
+The helper installs steamcmd under `~/.adaptfully/steamcmd` when needed, logs in (enter a Steam Guard code if prompted), and writes `assets/meta/deployments/steam/steam.json`.
+
+### 3. Manual alternative: install steamcmd
+
+Skip this if you used step 2.
+
+Download steamcmd for your OS from Valve and unpack it somewhere durable.
+
+### 4. Manual alternative: log in once
+
+Skip this if you used step 2.
+
+```bash
+steamcmd +login YOUR_USER YOUR_PASSWORD +quit
+```
+
+Complete Steam Guard if prompted. After a successful login, steamcmd stores session files under its install directory (`config/config.vdf`, and an `ssfn*` sentry file when Guard is enabled).
+
+### 5. Manual alternative: assemble `steam.json`
+
+Skip this if you used step 2.
+
+Create `assets/meta/deployments/steam/steam.json`:
+
+```json
+{
+  "username": "(your Steam build account)",
+  "password": "(your password)",
+  "configVdf": "(base64 of config/config.vdf)",
+  "sentryFileName": "(ssfn filename — only with Steam Guard)",
+  "sentryFile": "(base64 of the ssfn file — only with Steam Guard)"
+}
+```
+
+Accounts **without** Steam Guard only need `username`, `password`, and `configVdf`.
+
+### 6. App IDs (client vs upload)
+
+These are independent:
+
+| Setting | Purpose |
+|---------|---------|
+| `config.platforms.<name>.steamId` | Client Steamworks / `steam-auth` |
+| `assets/meta/deployments/steam/manifest.json` → `steamId` | Depot upload target |
+
+You can ship with Steam auth and no upload credentials, or upload without client Steamworks.
+
+Example `manifest.json`:
+
+```json
+{
+  "type": "steam",
+  "steamId": 480
+}
+```
+
+### 7. Done when
+
+- [ ] For uploads: `steam.json` exists and login tokens are valid
+- [ ] Upload `steamId` is set on the deployment manifest
+- [ ] Client `steamId` is set on the platform if you use Steamworks auth
+- [ ] Credential files are gitignored
+
+## Notes
+
+- Re-run `adaptfully steam-publish` when Steam invalidates the token (new machine, password change, or expired Guard).
+- `steam-dev` never requires `steam.json`.

package/lib/node/android-keystore.js

@@ -0,0 +1,243 @@
+import { spawn } from 'node:child_process';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import {
+    defaultDeploymentCredentialPath,
+    ensureDeploymentManifest,
+    ensurePublishCredentialsGitignore,
+    parsePublishCredentialArgv,
+    promptConfirm,
+    promptRequired,
+} from './publish-credentials.js';
+
+const DEBUG_ALIAS = 'androiddebugkey';
+const DEBUG_PASSWORD = 'android';
+const DEBUG_DNAME = 'CN=Android Debug,O=Android,C=US';
+
+/**
+ * @param {string} [projectRoot]
+ * @param {string} [deploymentKey='android']
+ */
+export function defaultAndroidDeploymentDir(projectRoot = '.', deploymentKey = 'android') {
+    return path.dirname(defaultDeploymentCredentialPath(projectRoot, deploymentKey, 'build.json'));
+}
+
+/**
+ * @param {{
+ *   debugOnly?: boolean,
+ *   debug?: { keystore: string, storePassword: string, alias: string, password: string },
+ *   release?: { keystore: string, storePassword: string, alias: string, password: string },
+ * }} options
+ */
+export function buildAndroidBuildJson(options = {}) {
+    /** @type {Record<string, unknown>} */
+    const android = {
+        debug: {
+            keystore: options.debug?.keystore ?? './android/debug.keystore',
+            packageType: 'apk',
+            storePassword: options.debug?.storePassword ?? DEBUG_PASSWORD,
+            alias: options.debug?.alias ?? DEBUG_ALIAS,
+            password: options.debug?.password ?? DEBUG_PASSWORD,
+            keystoreType: '',
+        },
+    };
+
+    if (!options.debugOnly && options.release) {
+        android.release = {
+            keystore: options.release.keystore,
+            packageType: 'bundle',
+            storePassword: options.release.storePassword,
+            alias: options.release.alias,
+            password: options.release.password,
+            keystoreType: '',
+        };
+    }
+
+    return { android };
+}
+
+/**
+ * @param {string[]} args
+ * @param {{ command?: string }} [options]
+ * @returns {Promise<void>}
+ */
+export function runKeytool(args, options = {}) {
+    const command = options.command ?? 'keytool';
+
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: process.platform === 'win32',
+        });
+
+        let stderr = '';
+        child.stderr?.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on('error', (err) => {
+            reject(new Error(
+                `Unable to run "${command}". Install a JDK and ensure keytool is on PATH. (${err.message})`,
+            ));
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`keytool failed (exit ${code}): ${stderr.trim() || 'no output'}`));
+        });
+    });
+}
+
+/**
+ * @param {{
+ *   keystorePath: string,
+ *   alias: string,
+ *   storePassword: string,
+ *   keyPassword: string,
+ *   dname: string,
+ *   validityDays?: number,
+ *   runKeytoolFn?: typeof runKeytool,
+ * }} options
+ */
+export async function generateKeystore(options) {
+    const run = options.runKeytoolFn ?? runKeytool;
+    await fsp.mkdir(path.dirname(options.keystorePath), { recursive: true });
+    await run([
+        '-genkeypair',
+        '-v',
+        '-keystore', options.keystorePath,
+        '-alias', options.alias,
+        '-keyalg', 'RSA',
+        '-keysize', '2048',
+        '-validity', String(options.validityDays ?? 10000),
+        '-storepass', options.storePassword,
+        '-keypass', options.keyPassword,
+        '-dname', options.dname,
+    ]);
+}
+
+/**
+ * @param {{
+ *   deployment?: string,
+ *   projectRoot?: string,
+ *   debugOnly?: boolean,
+ *   yes?: boolean,
+ *   alias?: string,
+ *   storePassword?: string,
+ *   keyPassword?: string,
+ *   cn?: string,
+ *   log?: (message: string) => void,
+ *   runKeytoolFn?: typeof runKeytool,
+ * }} [options]
+ */
+export async function runAndroidKeystore(options = {}) {
+    const log = options.log ?? console.log;
+    const projectRoot = options.projectRoot ?? '.';
+    const deploymentKey = options.deployment ?? 'android';
+    const deploymentDir = defaultAndroidDeploymentDir(projectRoot, deploymentKey);
+    const keystoreDir = path.join(deploymentDir, 'android');
+    const buildJsonPath = path.join(deploymentDir, 'build.json');
+    const debugOnly = options.debugOnly === true;
+
+    let buildJsonExists = false;
+    try {
+        await fsp.access(buildJsonPath);
+        buildJsonExists = true;
+    } catch {
+        buildJsonExists = false;
+    }
+
+    if (buildJsonExists) {
+        const overwrite = options.yes === true
+            || await promptConfirm(`Overwrite existing ${buildJsonPath}?`, false);
+        if (!overwrite) {
+            throw new Error(`Refusing to overwrite ${buildJsonPath}. Pass --yes to overwrite.`);
+        }
+    }
+
+    const debugKeystorePath = path.join(keystoreDir, 'debug.keystore');
+    log(`adaptfully: generating debug keystore → ${debugKeystorePath}`);
+    await generateKeystore({
+        keystorePath: debugKeystorePath,
+        alias: DEBUG_ALIAS,
+        storePassword: DEBUG_PASSWORD,
+        keyPassword: DEBUG_PASSWORD,
+        dname: DEBUG_DNAME,
+        runKeytoolFn: options.runKeytoolFn,
+    });
+
+    /** @type {{ keystore: string, storePassword: string, alias: string, password: string } | undefined} */
+    let release;
+
+    if (!debugOnly) {
+        const alias = options.alias
+            ?? await promptRequired('Release keystore alias: ');
+        const storePassword = options.storePassword
+            ?? await promptRequired('Release store password: ');
+        const keyPassword = options.keyPassword
+            ?? options.storePassword
+            ?? await promptRequired('Release key password (often same as store): ');
+        const cn = options.cn
+            ?? await promptRequired('Certificate CN (e.g. Your Studio): ');
+
+        const releaseKeystorePath = path.join(keystoreDir, 'release.keystore');
+        log(`adaptfully: generating release keystore → ${releaseKeystorePath}`);
+        await generateKeystore({
+            keystorePath: releaseKeystorePath,
+            alias,
+            storePassword,
+            keyPassword,
+            dname: `CN=${cn},O=${cn},C=US`,
+            runKeytoolFn: options.runKeytoolFn,
+        });
+
+        release = {
+            keystore: './android/release.keystore',
+            storePassword,
+            alias,
+            password: keyPassword,
+        };
+    }
+
+    const buildJson = buildAndroidBuildJson({
+        debugOnly,
+        debug: {
+            keystore: './android/debug.keystore',
+            storePassword: DEBUG_PASSWORD,
+            alias: DEBUG_ALIAS,
+            password: DEBUG_PASSWORD,
+        },
+        release,
+    });
+
+    await fsp.mkdir(deploymentDir, { recursive: true });
+    await fsp.writeFile(buildJsonPath, `${JSON.stringify(buildJson, null, 4)}\n`);
+    await ensureDeploymentManifest(deploymentDir, 'google', log);
+    await ensurePublishCredentialsGitignore(projectRoot, {
+        extraPaths: [buildJsonPath, keystoreDir],
+        log,
+    });
+
+    log(`adaptfully: wrote ${buildJsonPath}`);
+    if (debugOnly) {
+        log('adaptfully: debug-only keystore ready. For Play uploads, re-run without --debug-only, then use google-publish.');
+    } else {
+        log('adaptfully: next — create a Play Console service account JSON, then: adaptfully google-publish --from <sa.json>');
+    }
+
+    return {
+        deploymentKey,
+        deploymentDir,
+        buildJsonPath,
+        buildJson,
+        debugOnly,
+    };
+}
+
+/**
+ * @param {string[]} [argv]
+ */
+export async function androidKeystoreFromCli(argv = process.argv) {
+    return runAndroidKeystore(parsePublishCredentialArgv(argv));
+}

package/lib/node/apple-signing.js

@@ -0,0 +1,392 @@
+import { spawn } from 'node:child_process';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import {
+    defaultDeploymentCredentialPath,
+    ensureDeploymentManifest,
+    ensurePublishCredentialsGitignore,
+    parsePublishCredentialArgv,
+    promptConfirm,
+    promptRequired,
+    resolveUserPath,
+} from './publish-credentials.js';
+
+/** @typedef {'development' | 'distribution'} AppleSigningKind */
+
+/**
+ * @param {string} [projectRoot]
+ * @param {string} [deploymentKey='ios']
+ */
+export function defaultAppleSigningDir(projectRoot = '.', deploymentKey = 'ios') {
+    return path.join(
+        path.dirname(defaultDeploymentCredentialPath(projectRoot, deploymentKey, 'apple.json')),
+        'apple',
+    );
+}
+
+/**
+ * @param {string} kind
+ * @returns {AppleSigningKind}
+ */
+export function normalizeAppleSigningKind(kind) {
+    const value = String(kind ?? '').trim().toLowerCase();
+    if (value === 'development' || value === 'dev' || value === 'debug') {
+        return 'development';
+    }
+    if (value === 'distribution' || value === 'dist' || value === 'release' || value === 'app-store') {
+        return 'distribution';
+    }
+    throw new Error(
+        `Unknown Apple signing kind "${kind}". Use "development" or "distribution".`,
+    );
+}
+
+/**
+ * @param {AppleSigningKind} kind
+ */
+export function appleSigningFilenames(kind) {
+    if (kind === 'development') {
+        return {
+            p12: 'development.p12',
+            provision: 'development.mobileprovision',
+            certLabel: 'Apple Development',
+        };
+    }
+    return {
+        p12: 'distribution.p12',
+        provision: 'app-store.mobileprovision',
+        certLabel: 'Apple Distribution',
+    };
+}
+
+/**
+ * Merge or create build.json with apple.p12Password.
+ * @param {object | null | undefined} existing
+ * @param {string} p12Password
+ */
+export function mergeAppleP12PasswordBuildJson(existing, p12Password) {
+    /** @type {Record<string, unknown>} */
+    const next = existing && typeof existing === 'object' && !Array.isArray(existing)
+        ? { ...existing }
+        : {};
+    const apple = next.apple && typeof next.apple === 'object' && !Array.isArray(next.apple)
+        ? { .../** @type {Record<string, unknown>} */ (next.apple) }
+        : {};
+    apple.p12Password = p12Password;
+    next.apple = apple;
+    return next;
+}
+
+/**
+ * @param {string[]} args
+ * @param {{ command?: string }} [options]
+ * @returns {Promise<void>}
+ */
+export function runOpenssl(args, options = {}) {
+    const command = options.command ?? 'openssl';
+
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: process.platform === 'win32',
+        });
+
+        let stderr = '';
+        child.stderr?.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on('error', (err) => {
+            reject(new Error(
+                `Unable to run "${command}". Install OpenSSL and ensure it is on PATH. (${err.message})`,
+            ));
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`openssl failed (exit ${code}): ${stderr.trim() || 'no output'}`));
+        });
+    });
+}
+
+/**
+ * @param {{
+ *   workdir: string,
+ *   cn: string,
+ *   email?: string,
+ *   runOpensslFn?: typeof runOpenssl,
+ * }} options
+ */
+export async function generateAppleCsr(options) {
+    const run = options.runOpensslFn ?? runOpenssl;
+    await fsp.mkdir(options.workdir, { recursive: true });
+
+    const keyPath = path.join(options.workdir, 'private.key');
+    const csrPath = path.join(options.workdir, 'CertificateSigningRequest.certSigningRequest');
+    const subject = options.email
+        ? `/emailAddress=${options.email}/CN=${options.cn}/C=US`
+        : `/CN=${options.cn}/C=US`;
+
+    await run(['genrsa', '-out', keyPath, '2048']);
+    await run([
+        'req',
+        '-new',
+        '-key', keyPath,
+        '-out', csrPath,
+        '-subj', subject,
+    ]);
+
+    return { keyPath, csrPath };
+}
+
+/**
+ * @param {{
+ *   cerPath: string,
+ *   keyPath: string,
+ *   p12Path: string,
+ *   p12Password: string,
+ *   runOpensslFn?: typeof runOpenssl,
+ * }} options
+ */
+export async function exportAppleP12(options) {
+    const run = options.runOpensslFn ?? runOpenssl;
+    await fsp.mkdir(path.dirname(options.p12Path), { recursive: true });
+
+    const pemPath = `${options.cerPath}.pem`;
+    await run(['x509', '-in', options.cerPath, '-inform', 'DER', '-out', pemPath, '-outform', 'PEM']);
+
+    try {
+        await run([
+            'pkcs12',
+            '-export',
+            '-inkey', options.keyPath,
+            '-in', pemPath,
+            '-out', options.p12Path,
+            '-passout', `pass:${options.p12Password}`,
+        ]);
+    } catch (derErr) {
+        // Some downloads are already PEM
+        try {
+            await run([
+                'pkcs12',
+                '-export',
+                '-inkey', options.keyPath,
+                '-in', options.cerPath,
+                '-out', options.p12Path,
+                '-passout', `pass:${options.p12Password}`,
+            ]);
+        } catch {
+            throw derErr;
+        }
+    } finally {
+        try {
+            await fsp.unlink(pemPath);
+        } catch {
+            // ignore
+        }
+    }
+}
+
+/**
+ * @param {(message: string) => void} log
+ * @param {AppleSigningKind} kind
+ * @param {string} csrPath
+ */
+function printPortalChecklist(log, kind, csrPath) {
+    const names = appleSigningFilenames(kind);
+    log('');
+    log('adaptfully: Apple Developer portal steps (browser):');
+    log(`  1. Open https://developer.apple.com/account/resources/certificates/list`);
+    log(`  2. Create a new "${names.certLabel}" certificate`);
+    log(`  3. Upload CSR: ${csrPath}`);
+    log('  4. Download the .cer file');
+    log('  5. Ensure your App ID exists; enable Sign in with Apple if you use Capgo Apple auth');
+    if (kind === 'development') {
+        log('  6. Register device UDIDs, then create a Development provisioning profile');
+    } else {
+        log('  6. Create an App Store Connect provisioning profile for the App ID');
+    }
+    log('  7. Download the .mobileprovision file');
+    log('');
+}
+
+/**
+ * @param {{
+ *   deployment?: string,
+ *   projectRoot?: string,
+ *   workdir?: string,
+ *   csrOnly?: boolean,
+ *   fromCer?: string,
+ *   kind?: string,
+ *   provision?: string,
+ *   p12Password?: string,
+ *   cn?: string,
+ *   email?: string,
+ *   yes?: boolean,
+ *   log?: (message: string) => void,
+ *   runOpensslFn?: typeof runOpenssl,
+ * }} [options]
+ */
+export async function runAppleSigning(options = {}) {
+    const log = options.log ?? console.log;
+    const projectRoot = options.projectRoot ?? '.';
+    const deploymentKey = options.deployment ?? 'ios';
+    const appleDir = defaultAppleSigningDir(projectRoot, deploymentKey);
+    const deploymentDir = path.dirname(appleDir);
+    const workdir = path.resolve(
+        options.workdir
+            ?? path.join(appleDir, '.work'),
+    );
+
+    let kind = options.kind
+        ? normalizeAppleSigningKind(options.kind)
+        : null;
+
+    if (!kind && (options.fromCer || options.provision || !options.csrOnly)) {
+        kind = normalizeAppleSigningKind(
+            await promptRequired('Signing kind (development|distribution): ', options.kind),
+        );
+    }
+
+    if (!kind) {
+        kind = 'development';
+    }
+
+    const names = appleSigningFilenames(kind);
+    const keyPath = path.join(workdir, 'private.key');
+    const csrPath = path.join(workdir, 'CertificateSigningRequest.certSigningRequest');
+
+    let createdCsr = false;
+    try {
+        await fsp.access(keyPath);
+        await fsp.access(csrPath);
+    } catch {
+        const cn = options.cn ?? await promptRequired('Common name for CSR (e.g. Your Name): ');
+        const email = options.email;
+        log(`adaptfully: generating CSR in ${workdir}`);
+        await generateAppleCsr({
+            workdir,
+            cn,
+            email,
+            runOpensslFn: options.runOpensslFn,
+        });
+        createdCsr = true;
+    }
+
+    printPortalChecklist(log, kind, csrPath);
+
+    if (options.csrOnly) {
+        await ensurePublishCredentialsGitignore(projectRoot, {
+            extraPaths: [appleDir],
+            log,
+        });
+        log('adaptfully: --csr-only set; stop here, then re-run with --from-cer after downloading the .cer');
+        return {
+            deploymentKey,
+            appleDir,
+            workdir,
+            csrPath,
+            keyPath,
+            kind,
+            csrOnly: true,
+            createdCsr,
+        };
+    }
+
+    const cerPath = resolveUserPath(
+        await promptRequired('Path to downloaded Apple .cer: ', options.fromCer),
+    );
+
+    const p12Password = options.p12Password != null
+        ? String(options.p12Password)
+        : await promptRequired('Passphrase for the .p12 (remember this for build.json apple.p12Password): ');
+
+    const p12Path = path.join(appleDir, names.p12);
+    log(`adaptfully: exporting ${p12Path}`);
+    await exportAppleP12({
+        cerPath,
+        keyPath,
+        p12Path,
+        p12Password,
+        runOpensslFn: options.runOpensslFn,
+    });
+
+    const buildJsonPath = path.join(deploymentDir, 'build.json');
+    let existingBuild = null;
+    try {
+        existingBuild = JSON.parse(await fsp.readFile(buildJsonPath, 'utf8'));
+    } catch {
+        existingBuild = null;
+    }
+
+    const writePassword = options.yes === true
+        || p12Password === ''
+        || await promptConfirm(
+            `Write apple.p12Password into ${buildJsonPath}?`,
+            true,
+        );
+
+    if (writePassword) {
+        const merged = mergeAppleP12PasswordBuildJson(existingBuild, p12Password);
+        await fsp.mkdir(deploymentDir, { recursive: true });
+        await fsp.writeFile(buildJsonPath, `${JSON.stringify(merged, null, 4)}\n`);
+        log(`adaptfully: wrote ${buildJsonPath}`);
+    }
+
+    let provisionPath = options.provision;
+    if (!provisionPath) {
+        if (options.yes === true) {
+            log(`adaptfully: --yes set without --provision; skipping provisioning profile copy`);
+        } else {
+            const rlAnswer = await promptRequired(
+                `Path to downloaded ${names.provision} (type skip to finish later): `,
+            );
+            if (rlAnswer.toLowerCase() !== 'skip') {
+                provisionPath = rlAnswer;
+            }
+        }
+    }
+
+    if (provisionPath) {
+        const dest = path.join(appleDir, names.provision);
+        await fsp.mkdir(appleDir, { recursive: true });
+        await fsp.copyFile(resolveUserPath(provisionPath), dest);
+        log(`adaptfully: copied provisioning profile → ${dest}`);
+    } else {
+        log(`adaptfully: skipped provisioning profile — place ${names.provision} under ${appleDir} when ready`);
+    }
+
+    await ensureDeploymentManifest(deploymentDir, 'apple', log);
+    await ensurePublishCredentialsGitignore(projectRoot, {
+        extraPaths: [appleDir, buildJsonPath],
+        log,
+    });
+
+    log(`adaptfully: signing files under ${appleDir}`);
+    if (kind === 'distribution') {
+        log('adaptfully: next for App Store upload — adaptfully apple-publish');
+    } else {
+        log('adaptfully: development signing ready for ios-dev device builds');
+    }
+
+    return {
+        deploymentKey,
+        appleDir,
+        workdir,
+        csrPath,
+        keyPath,
+        p12Path,
+        kind,
+        csrOnly: false,
+        createdCsr,
+        provisionPath: provisionPath ? resolveUserPath(provisionPath) : null,
+    };
+}
+
+/**
+ * @param {string[]} [argv]
+ */
+export async function appleSigningFromCli(argv = process.argv) {
+    return runAppleSigning(parsePublishCredentialArgv(argv));
+}

package/lib/node/index.js

@@ -62,6 +62,7 @@ export {
     ensurePublishCredentialsGitignore,
     normalizeUserPath,
     parsePublishCredentialArgv,
+    promptConfirm,
     promptRequired,
     PUBLISH_CREDENTIAL_GITIGNORE_PATTERNS,
     resolveUserPath,
@@ -90,3 +91,22 @@ export {
     runApplePublish,
     validateApplePublishJson,
 } from './apple-publish.js';
+export {
+    androidKeystoreFromCli,
+    buildAndroidBuildJson,
+    defaultAndroidDeploymentDir,
+    generateKeystore,
+    runAndroidKeystore,
+    runKeytool,
+} from './android-keystore.js';
+export {
+    appleSigningFilenames,
+    appleSigningFromCli,
+    defaultAppleSigningDir,
+    exportAppleP12,
+    generateAppleCsr,
+    mergeAppleP12PasswordBuildJson,
+    normalizeAppleSigningKind,
+    runAppleSigning,
+    runOpenssl,
+} from './apple-signing.js';

package/lib/node/pipeline.js

@@ -12,6 +12,8 @@ import {
 import { steamPublishFromCli } from './steam-publish.js';
 import { googlePublishFromCli } from './google-publish.js';
 import { applePublishFromCli } from './apple-publish.js';
+import { androidKeystoreFromCli } from './android-keystore.js';
+import { appleSigningFromCli } from './apple-signing.js';
 
 /** @typedef {'prebuild' | 'build' | 'deploy' | 'release'} AdaptfullyStage */
 
@@ -20,6 +22,8 @@ const PUBLISH_COMMANDS = {
     'steam-publish': steamPublishFromCli,
     'google-publish': googlePublishFromCli,
     'apple-publish': applePublishFromCli,
+    'android-keystore': androidKeystoreFromCli,
+    'apple-signing': appleSigningFromCli,
 };
 
 /**
@@ -202,6 +206,8 @@ export async function adaptfullyFromCli(argv = process.argv) {
             + '  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'
+            + '  adaptfully android-keystore [--deployment android] [--debug-only] [--yes]\n'
+            + '  adaptfully apple-signing [--deployment ios] [--kind development|distribution] [--csr-only] [--from-cer path] [--provision path]\n'
             + '\n'
             + 'Stages:\n'
             + '  prebuild  Copy deploy/ and apply platform registrations → output/<platform>-prebuild/\n'
@@ -213,9 +219,11 @@ export async function adaptfullyFromCli(argv = process.argv) {
             + '  --artifact <path>   Prior build artifact directory (deploy only; default: ./output/ after build).\n'
             + '\n'
             + 'Publish credential helpers (one-time local setup):\n'
-            + '  steam-publish   Install steamcmd if needed, log in, write steam deployment steam.json\n'
-            + '  google-publish  Import a Play service-account JSON into the android deployment folder\n'
-            + '  apple-publish   Write App Store Connect credentials into the ios deployment folder',
+            + '  steam-publish     Install steamcmd if needed, log in, write steam deployment steam.json\n'
+            + '  google-publish    Import a Play service-account JSON into the android deployment folder\n'
+            + '  apple-publish     Write App Store Connect credentials into the ios deployment folder\n'
+            + '  android-keystore  Generate debug/release keystores and write android build.json\n'
+            + '  apple-signing     Generate CSR, export .p12, place provisioning profiles under ios/apple/',
         );
     }
 

package/lib/node/publish-credentials.js

@@ -211,13 +211,33 @@ export async function promptRequired(prompt, existing) {
     }
 }
 
+/**
+ * @param {string} prompt
+ * @param {boolean} [defaultYes=false]
+ * @returns {Promise<boolean>}
+ */
+export async function promptConfirm(prompt, defaultYes = false) {
+    const rl = readline.createInterface({ input, output });
+    const suffix = defaultYes ? ' [Y/n] ' : ' [y/N] ';
+
+    try {
+        const answer = String(await rl.question(`${prompt}${suffix}`)).trim().toLowerCase();
+        if (!answer) {
+            return defaultYes;
+        }
+        return answer === 'y' || answer === 'yes';
+    } finally {
+        rl.close();
+    }
+}
+
 /**
  * Parse shared CLI flags used by publish credential helpers.
  * @param {string[]} argv
  * @param {number} [startIndex=3]
  */
 export function parsePublishCredentialArgv(argv, startIndex = 3) {
-    /** @type {Record<string, string>} */
+    /** @type {Record<string, string | boolean>} */
     const options = {
         projectRoot: '.',
     };
@@ -243,6 +263,32 @@ export function parsePublishCredentialArgv(argv, startIndex = 3) {
             options.username = argv[++i];
         } else if (arg === '--password' && argv[i + 1]) {
             options.password = argv[++i];
+        } else if (arg === '--debug-only') {
+            options.debugOnly = true;
+        } else if (arg === '--csr-only') {
+            options.csrOnly = true;
+        } else if (arg === '--yes' || arg === '-y') {
+            options.yes = true;
+        } else if (arg === '--from-cer' && argv[i + 1]) {
+            options.fromCer = normalizeUserPath(argv[++i]);
+        } else if (arg === '--kind' && argv[i + 1]) {
+            options.kind = argv[++i];
+        } else if (arg === '--provision' && argv[i + 1]) {
+            options.provision = normalizeUserPath(argv[++i]);
+        } else if (arg === '--workdir' && argv[i + 1]) {
+            options.workdir = normalizeUserPath(argv[++i]);
+        } else if (arg === '--alias' && argv[i + 1]) {
+            options.alias = argv[++i];
+        } else if (arg === '--store-password' && argv[i + 1]) {
+            options.storePassword = argv[++i];
+        } else if (arg === '--key-password' && argv[i + 1]) {
+            options.keyPassword = argv[++i];
+        } else if (arg === '--p12-password' && argv[i + 1]) {
+            options.p12Password = argv[++i];
+        } else if (arg === '--cn' && argv[i + 1]) {
+            options.cn = argv[++i];
+        } else if (arg === '--email' && argv[i + 1]) {
+            options.email = argv[++i];
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@makefully/adaptfully",
-    "version": "4.0.0",
+    "version": "4.1.0",
     "description": "Platform abstraction and Wrapfully deploy client for Makefully games",
     "type": "module",
     "main": "./lib/node/index.js",
@@ -17,6 +17,7 @@
     "files": [
         "bin",
         "lib",
+        "docs",
         "CHANGELOG.md",
         "LICENSE",
         "README.md"