@makefully/adaptfully 3.16.1 → 4.1.0

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

@@ -23,7 +23,6 @@ export { prebuildPlatform, prebuildOutputDir, resolveHtmlInjections } from './pr
 export { getPackageRoot, getRuntimeDir, resolveRuntimeScript } from './paths.js';
 export {
     CapacitorPackager,
-    CordovaPackager,
     ElectronPackager,
     Packager,
     VALID_PACKAGERS,
@@ -63,6 +62,7 @@ export {
     ensurePublishCredentialsGitignore,
     normalizeUserPath,
     parsePublishCredentialArgv,
+    promptConfirm,
     promptRequired,
     PUBLISH_CREDENTIAL_GITIGNORE_PATTERNS,
     resolveUserPath,
@@ -91,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/packagers/base.js

@@ -4,10 +4,10 @@ import { STANDARD_PLUGINS } from '../registrations.js';
 import { resolvePlatformConfig } from '../platform-config.js';
 
 /** @typedef {import('../registrations.js').RegistrationMap} RegistrationMap */
-/** @typedef {'web' | 'electron' | 'cordova' | 'capacitor'} PackagerName */
+/** @typedef {'web' | 'electron' | 'capacitor'} PackagerName */
 
 /** @type {PackagerName[]} */
-export const VALID_PACKAGERS = ['web', 'electron', 'cordova', 'capacitor'];
+export const VALID_PACKAGERS = ['web', 'electron', 'capacitor'];
 
 const PACKAGER_MARKER = '<!-- adaptfully-packager -->';
 const PACKAGER_END_MARKER = '<!-- /adaptfully-packager -->';
@@ -16,7 +16,7 @@ const HEAD_PACKAGER_END_MARKER = '<!-- /adaptfully-packager-head -->';
 
 /**
  * @typedef {Object} PackagerOptions
- * @property {string[]} [platforms] Platform keys this packager targets (e.g. ios + android for Cordova)
+ * @property {string[]} [platforms] Platform keys this packager targets
  * @property {string} [platformKey] Active platform for a single prebuild run
  * @property {(message: string) => void} [log]
  */