crossbind 2.0.0-beta.68 → 2.0.0-beta.69

package/src/actions/extensionApi.js

@@ -0,0 +1,298 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import state from '../state/index.js';
+import { exportOf } from '../state/loadConfig.js';
+import loadSystemConfig, { extensionSettingsOf, updateSystemConfig } from '../utils/systemConfig.js';
+import systemKeys from '../utils/systemKeys.js';
+import { askLine, askYesNo, hasTerminal } from '../utils/ask.js';
+import openUrl from '../utils/openUrl.js';
+import { readSecret, storeSecret } from '../utils/keychain.js';
+import { configChangesOf } from '../utils/configChanges.js';
+import { entry, writeOption } from '../utils/configWriter.js';
+import { readAppIcon, windowsIcon } from '../utils/appIcon.js';
+import {
+    PRIVACY_CATEGORIES, androidAppId, appCategory, appDisplayName, appEncryption, appId, appPrivacy, appUrlSchemes,
+} from '../utils/appOptions.js';
+import { isJsonValue, linuxDepends } from '../utils/appExtensions.js';
+import { fileTypeOwners } from '../utils/appLaunches.js';
+import { unreasonedImports } from '../utils/requiredReasonApis.js';
+import { resolveHermesDsym } from '../utils/hermes.js';
+import { imageRoleFor } from '../utils/pullDockerImage.js';
+import { isUnderBase } from '../utils/replaceBasePathForDocker.js';
+import {
+    androidVersion, appBuildNumber, appTeam, appVersion,
+} from './buildApp.js';
+import runTool from './run.js';
+import { makeUploadKey, releaseSigningEnv } from './uploadKey.js';
+import { appStoreKey } from './appleSigning.js';
+import { inWindowsImage, jsignScript, windowsSigning } from './windowsSigning.js';
+import { xcodebuild, xcodeTeams } from './xcodebuild.js';
+
+// The api an extension's build-side code gets in place of crossbind's own modules, which it never imports: what the run
+// is, the project and its app as the build reads them, the terminal, this machine's settings and keychain, and the
+// signing and tools crossbind builds and packages each platform's apps with.
+
+const PATH_PART = /^[A-Za-z_$][\w$]*$/;
+const SETTING = /^[A-Z][A-Z0-9_]*$/;
+const ACCOUNT = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+
+function refuse() {
+    throw new TypeError('crossbind: api.config is read-only: api.config.write writes an option into crossbind.config.js.');
+}
+
+const views = new WeakMap();
+const READ_ONLY = {
+    get(target, key, receiver) {
+        const value = Reflect.get(target, key, receiver);
+        const own = Reflect.getOwnPropertyDescriptor(target, key);
+        // A proxy gives a property that never changes as it is.
+        if (own && !own.configurable && !own.writable) return value;
+        return readOnly(value);
+    },
+    // A configurable property's value is a view too; one that never changes is given as it is, as a proxy must.
+    getOwnPropertyDescriptor(target, key) {
+        const own = Reflect.getOwnPropertyDescriptor(target, key);
+        return own?.configurable && 'value' in own ? { ...own, value: readOnly(own.value) } : own;
+    },
+    set: refuse,
+    defineProperty: refuse,
+    deleteProperty: refuse,
+    setPrototypeOf: refuse,
+    preventExtensions: refuse,
+};
+
+function readOnly(value) {
+    if (value === null || typeof value !== 'object') return value;
+    if (!views.has(value)) views.set(value, new Proxy(value, READ_ONLY));
+    return views.get(value);
+}
+
+// crossbind.config.js's export as the run's config read it, with the app's options the api wrote since, which the run's
+// config holds: each read sees them, however long ago the extension took the view.
+function configView(write) {
+    const current = () => ({ ...exportOf(state.config), app: state.config.app });
+    return new Proxy({}, {
+        get: (target, key) => (key === 'write' ? write : readOnly(current()[key])),
+        has: (target, key) => key in current(),
+        ownKeys: () => Reflect.ownKeys(current()),
+        getOwnPropertyDescriptor(target, key) {
+            const own = Reflect.getOwnPropertyDescriptor(current(), key);
+            return own && { ...own, value: readOnly(own.value) };
+        },
+        set: refuse,
+        defineProperty: refuse,
+        deleteProperty: refuse,
+        setPrototypeOf: refuse,
+        preventExtensions: refuse,
+    });
+}
+
+const deepFrozen = (value) => {
+    if (value !== null && typeof value === 'object') Object.values(value).forEach(deepFrozen);
+    return Object.freeze(value);
+};
+
+const valueAt = (object, keys) => keys.reduce((value, key) => (isObject(value) ? value[key] : undefined), object);
+const withValue = (object, [key, ...rest], value) => ({ ...object, [key]: rest.length === 0 ? value : withValue(isObject(object?.[key]) ? object[key] : {}, rest, value) });
+
+// What crossbind checks of an option written into crossbind.config.js, as its builds read it.
+const OPTION_CHECKS = {
+    'app.id': (config, platform) => (platform === 'android' ? androidAppId(config) : appId(config)),
+    'app.name': appDisplayName,
+    'app.icon': readAppIcon,
+    'app.encryption': appEncryption,
+    'app.privacy': appPrivacy,
+};
+
+// Writes an option into crossbind.config.js once the user says yes on a terminal, and into this run's config: one of
+// those crossbind checks as the builds would, alone. One the config sets already is the user's to change, and one the
+// builds would refuse fails as invalid, for the caller to ask again.
+async function writeConfig(name, platform, key, value) {
+    const keys = typeof key === 'string' ? key.split('.') : [];
+    if (keys.length === 0 || !keys.every((part) => PATH_PART.test(part))) throw new Error(`crossbind: ${name} names ${JSON.stringify(key)}, which is no option of crossbind.config.js, as 'app.id' is.`);
+    if (!Object.hasOwn(OPTION_CHECKS, key)) {
+        const writable = Object.keys(OPTION_CHECKS);
+        throw new Error(`crossbind: ${name} writes ${key}, which api.config.write leaves to the app's developer: it writes ${writable.slice(0, -1).join(', ')} and ${writable.at(-1)} alone.`);
+    }
+    if (!isJsonValue(value)) throw new Error(`crossbind: ${name} gives ${key} a value that is no JSON value, which is all crossbind writes into crossbind.config.js.`);
+    // A copy of its own, as the value may hold the api's views of the config.
+    const plain = JSON.parse(JSON.stringify(value));
+    const text = `${keys.slice(0, -1).map((part) => `${part}.`).join('')}${entry(keys.at(-1), plain)}`;
+    if (valueAt(state.config, keys) !== undefined) throw new Error(`crossbind: set ${text} in crossbind.config.js in place of the ${key} there.`);
+    const changed = withValue(state.config, keys, plain);
+    try {
+        OPTION_CHECKS[key]?.(changed, platform);
+    } catch (error) {
+        throw Object.assign(error, { isInvalid: true });
+    }
+    if (!hasTerminal()) throw new Error(`crossbind: ${name} would write ${text} into crossbind.config.js, which takes a yes on a terminal: set it there yourself.`);
+    if (!await askYesNo(`Write ${text} into crossbind.config.js? [Y/n] `)) throw new Error(`crossbind: set ${text} in crossbind.config.js.`);
+    if (!writeOption(state.config.paths.project, keys, plain)) {
+        throw new Error(`crossbind: crossbind.config.js is no config crossbind can write ${key} into safely: set ${text} in it yourself.`);
+    }
+    state.config[keys[0]] = changed[keys[0]];
+}
+
+// This machine's settings: crossbind's own by their names, as `crossbind config set` takes them, and by any other name
+// the extension's own, which ~/.crossbind.json keeps apart for each extension.
+function settingsOf(name) {
+    const isCrossbinds = (key) => Object.hasOwn(systemKeys, key);
+    return Object.freeze({
+        get: (key) => (isCrossbinds(key) ? state.config.system[key] : extensionSettingsOf(state.config.system, name)[key]),
+        set(values) {
+            if (!isObject(values) || !Object.entries(values).every(([key, value]) => SETTING.test(key) && typeof value === 'string')) {
+                throw new Error(`crossbind: ${name} sets settings that are no object of this machine's settings, each an uppercase name with a string.`);
+            }
+            const entries = Object.entries(values);
+            entries.filter(([key]) => systemKeys[key]?.options).forEach(([key, value]) => {
+                if (!systemKeys[key].options.includes(value)) {
+                    throw new Error(`crossbind: ${name} sets ${key} to ${JSON.stringify(value)}, which takes ${systemKeys[key].options.join(', ')} alone.`);
+                }
+            });
+            const own = entries.filter(([key]) => !isCrossbinds(key));
+            updateSystemConfig(Object.fromEntries(entries.filter(([key]) => isCrossbinds(key))), own.length > 0 ? { name, values: Object.fromEntries(own) } : null);
+            state.config.system = loadSystemConfig();
+        },
+    });
+}
+
+// The keychain keeps an extension's secrets under its own service, each by a path the account names, as Windows keeps
+// one in a file beside that path.
+function secretsOf(name) {
+    const service = `crossbind ${name}`;
+    const keyOf = (account) => {
+        if (typeof account !== 'string' || !ACCOUNT.test(account)) throw new Error(`crossbind: ${name} names the secret ${JSON.stringify(account)}, which is no name of letters, digits, dots, dashes and underscores.`);
+        return path.join(os.homedir(), '.crossbind', 'secrets', name, account);
+    };
+    return Object.freeze({
+        get: (account) => readSecret(keyOf(account), { service }),
+        set(account, secret) {
+            const key = keyOf(account);
+            if (typeof secret !== 'string' || !secret) throw new Error(`crossbind: ${name} keeps no secret of ${account}, which is no text.`);
+            fs.mkdirSync(path.dirname(key), { recursive: true, mode: 0o700 });
+            return storeSecret(key, secret, { service });
+        },
+    });
+}
+
+function terminalOf(name) {
+    const assertTerminal = (question) => {
+        if (!hasTerminal()) throw new Error(`crossbind: ${name} asks ${JSON.stringify(question.trim())}, with no terminal to answer it.`);
+    };
+    return {
+        ask(question) {
+            assertTerminal(question);
+            return askLine(question);
+        },
+        askYesNo(question) {
+            assertTerminal(question);
+            return askYesNo(question);
+        },
+    };
+}
+
+// Runs a tool to its end where crossbind packages an app of the target's platform: on this Mac, with Apple's tools on
+// the PATH, for a macOS app, and for a Linux or Windows app in crossbind's image of its platform, which sees the
+// project's base alone, the windows one with the key that signs the app for a tool that signs. An installer's api alone
+// has the target of the app it makes.
+function runOf(name, target) {
+    return (command, options) => {
+        if (!target) throw new Error(`crossbind: ${name} runs a tool with api.run, which an installer's api alone has.`);
+        if (!Array.isArray(command) || command.length === 0 || !command.every((part) => typeof part === 'string')) {
+            throw new Error(`crossbind: ${name} runs no command with api.run, which takes a list of strings: the program and its arguments.`);
+        }
+        const { cwd = state.config.paths.project, isSigning = false } = options ?? {};
+        if (typeof cwd !== 'string') throw new Error(`crossbind: ${name} runs ${command[0]} in ${JSON.stringify(cwd)}, which is no path of a folder.`);
+        const dir = path.resolve(state.config.paths.project, cwd);
+        if (!fs.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) throw new Error(`crossbind: ${name} runs ${command[0]} in ${dir}, which is no folder.`);
+        if (target.platform !== 'darwin' && !isUnderBase(dir, state.config.paths.base)) {
+            throw new Error(`crossbind: ${name} runs ${command[0]} in ${dir}, outside ${state.config.paths.base}, the project's base and all the ${imageRoleFor(target)} container sees. Build the app into a folder under it.`);
+        }
+        if (target.platform === 'win32') inWindowsImage(command, dir, isSigning ? windowsSigning() : null);
+        else runTool(null, command, null, target, { workdir: dir });
+    };
+}
+
+// The api of an extension's run on a platform: the options the command line gave it, the run's build number once the
+// publish picked it, which the app's facts then show, and an installer's target, the app it makes.
+export default function extensionApi(name, {
+    platform, options = {}, isGuided, run = {}, target = null,
+}) {
+    const buildEnv = () => (run.buildNumber === undefined || run.buildNumber === null
+        ? process.env : { ...process.env, CROSSBIND_APP_BUILD_NUMBER: String(run.buildNumber) });
+    const config = configView((key, value) => writeConfig(name, platform, key, value));
+    return Object.freeze({
+        name,
+        platform,
+        isGuided,
+        options: Object.freeze({ ...options }),
+        project: Object.freeze({
+            get root() { return state.config.paths.project; },
+            get name() { return state.config.general.name; },
+            get package() { return readOnly(state.config.package); },
+        }),
+        get workDir() { return path.join(state.config.paths.build, name); },
+        config,
+        get publisherChanges() { return readOnly(configChangesOf()); },
+        app: Object.freeze({
+            get id() { return platform === 'android' ? androidAppId(state.config) : appId(state.config); },
+            get name() { return appDisplayName(state.config); },
+            get version() { return state.config.package?.version ?? '1.0.0'; },
+            get appleVersion() { return appVersion(); },
+            get versionCode() { return androidVersion(buildEnv()).code; },
+            get buildNumber() { return appBuildNumber(buildEnv()); },
+            get team() { return appTeam(); },
+            get encryption() { return appEncryption(state.config); },
+            get urlSchemes() { return Object.freeze(appUrlSchemes(state.config)); },
+            get fileTypes() { return Object.freeze(fileTypeOwners(state.config).map(({ extension, ...type }) => Object.freeze(type))); },
+            // The Debian packages a Linux app needs beside WebKitGTK and GTK, as its extensions' Linux parts list them.
+            get depends() { return Object.freeze(linuxDepends(state.config.extensions ?? [])); },
+            get category() {
+                const category = appCategory(state.config);
+                return category && Object.freeze({ macos: category.darwin, linux: category.linux });
+            },
+        }),
+        log: (text) => console.log(text),
+        warn: (text) => console.warn(text),
+        ...terminalOf(name),
+        openUrl(url) {
+            let address = null;
+            try {
+                address = new URL(url);
+            } catch {
+                // What is no URL is refused below.
+            }
+            if (!['http:', 'https:'].includes(address?.protocol)) throw new Error(`crossbind: ${name} opens ${JSON.stringify(url)}, which is no http or https address.`);
+            openUrl(address.href);
+        },
+        run: runOf(name, target),
+        settings: settingsOf(name),
+        secrets: secretsOf(name),
+        android: Object.freeze({
+            signing: () => releaseSigningEnv(),
+            async makeUploadKey() {
+                await makeUploadKey();
+                state.config.system = loadSystemConfig();
+            },
+        }),
+        apple: Object.freeze({
+            key: () => appStoreKey(),
+            teams: () => xcodeTeams(),
+            xcodebuild: (what, args, xcodebuildOptions) => xcodebuild(what, args, xcodebuildOptions),
+            unreasonedApis: (binary, privacy) => unreasonedImports(binary, privacy),
+            privacyCategories: deepFrozen(structuredClone(PRIVACY_CATEGORIES)),
+            dsyms: async () => [await resolveHermesDsym()],
+        }),
+        windows: Object.freeze({
+            icon() {
+                const icon = readAppIcon(state.config);
+                return icon && windowsIcon(icon);
+            },
+            // The script that signs a file in the windows image with the key, which a tool that signs as it builds runs.
+            get signer() { return windowsSigning() ? jsignScript() : null; },
+        }),
+    });
+}

package/src/actions/extensionCommands.js

@@ -0,0 +1,41 @@
+import { Option } from 'commander';
+import extensionApi from './extensionApi.js';
+import state from '../state/index.js';
+import { hasTerminal } from '../utils/ask.js';
+import { extensionStep, ownExtensions, withoutNamed } from '../utils/appExtensions.js';
+import resolveAppHostRoot from '../utils/resolveAppHost.js';
+
+const kebab = (name) => name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+
+// crossbind's own extensions a project has, none where its host is not installed, which each command that needs it says:
+// the commands of those app.without leaves out, and of those whose role or name another takes, go with them.
+function ownOf(listed, app) {
+    let root;
+    try {
+        root = resolveAppHostRoot();
+    } catch {
+        return [];
+    }
+    const taken = new Set(listed.flatMap(({ name, replaces }) => [name, ...(replaces ?? [])]));
+    return withoutNamed(ownExtensions(root), app).filter(({ name }) => !taken.has(name));
+}
+
+// Adds to crossbind app the commands of an app's extensions, crossbind's own and those crossbind.config.js lists: a name
+// another has stops the run, naming both.
+export default function addExtensionCommands(parent, config = state.config) {
+    if (config?.target?.runtimeEnv !== 'app') return;
+    const listed = config.extensions ?? [];
+    const owners = new Map(parent.commands.map((command) => [command.name(), 'crossbind']));
+    for (const { name: extension, commands = {} } of [...ownOf(listed, config.app), ...listed]) {
+        for (const [name, command] of Object.entries(commands)) {
+            if (owners.has(name)) throw new Error(`crossbind: ${extension} adds the command crossbind app ${name}, which ${owners.get(name)} has.`);
+            owners.set(name, extension);
+            const added = parent.command(name).description(command.help);
+            Object.entries(command.options).forEach(([option, { help, value, default: fallback }]) => {
+                const flag = new Option(`--${kebab(option)}${value ? ` ${value}` : ''}`, help);
+                added.addOption(fallback === null ? flag : flag.default(fallback));
+            });
+            added.action((options) => extensionStep(extension, name, () => command.run(extensionApi(extension, { platform: null, options, isGuided: hasTerminal() }))));
+        }
+    }
+}

package/src/actions/extensionsInApp.js

@@ -0,0 +1,19 @@
+import extensionApi from './extensionApi.js';
+import state from '../state/index.js';
+import {
+    appExtensionsOf, ownExtensions, withFromApp, withRoles, withoutNamed,
+} from '../utils/appExtensions.js';
+import resolveAppHostRoot from '../utils/resolveAppHost.js';
+
+// The platforms as an extension's api names them.
+const API_PLATFORMS = { darwin: 'macos', win32: 'windows' };
+
+// The extensions an app of this platform has: crossbind's own but those app.without leaves out, then those
+// crossbind.config.js lists, each with the roles it holds, which a listed one's replaces takes from the host's, and the
+// options it takes from the app's config, where it does.
+export default function extensionsInApp(platform, warn) {
+    const own = ownExtensions(resolveAppHostRoot());
+    const { app, extensions = [] } = state.config;
+    const held = withRoles(appExtensionsOf(withoutNamed(own, app)), appExtensionsOf(extensions), warn, appExtensionsOf(own));
+    return withFromApp(held, (name) => extensionApi(name, { platform: API_PLATFORMS[platform] ?? platform, isGuided: false }));
+}

package/src/actions/gradleProject.js

@@ -5,6 +5,8 @@ import { ANDROID_API_LEVEL } from '../utils/androidToolchain.js';
 import { HERMES } from '../utils/hermes.js';
 import resolveAppHostRoot from '../utils/resolveAppHost.js';
 import { SIGNING } from './androidGradle.js';
+import { appLinkParts } from '../utils/appLaunches.js';
+import { mergedVerification } from './mavenVerification.js';
 
 // The ABIs an Android app builds for: phones and Apple silicon's emulators, and the emulators of x86_64 machines.
 export const ANDROID_ABIS = ['arm64-v8a', 'x86_64'];
@@ -34,6 +36,14 @@ const backgroundValues = (color) => `<?xml version="1.0" encoding="utf-8"?>
 </resources>
 `;
 
+// The devices of app.permissions, which alone the page may ask for, whatever an extension's Java asks Android for.
+const permissionValues = (permissions) => `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string-array name="crossbind_permissions">${permissions.map((name) => `\n        <item>${name}</item>`).join('')}
+    </string-array>
+</resources>
+`;
+
 // The Android permissions behind each of app.permissions, after the one every app asks for; the activity asks its user
 // for them when the page first uses the device.
 const INTERNET = '    <uses-permission android:name="android.permission.INTERNET" />';
@@ -42,22 +52,138 @@ const ANDROID_PERMISSIONS = {
     microphone: ['RECORD_AUDIO', 'MODIFY_AUDIO_SETTINGS'],
     location: ['ACCESS_COARSE_LOCATION', 'ACCESS_FINE_LOCATION'],
 };
-const usesPermissions = (permissions) => permissions
-    .flatMap((name) => ANDROID_PERMISSIONS[name])
-    .map((permission) => `    <uses-permission android:name="android.permission.${permission}" />`);
+// The permissions the app asks for beside INTERNET, each once: app.permissions' and its extensions'.
+const usesPermissions = (permissions, extensionPermissions) => [...new Set([
+    ...permissions.flatMap((name) => ANDROID_PERMISSIONS[name]).map((permission) => `android.permission.${permission}`),
+    ...extensionPermissions,
+])].filter((permission) => permission !== 'android.permission.INTERNET')
+    .map((permission) => `    <uses-permission android:name="${permission}" />`);
+
+// What an extension's own manifest adds to the app's: the elements of its manifest, and those of its application, which
+// go inside the app's, whose attributes are the app's alone. The app's manifest declares the android and tools prefixes.
+const APPLICATION_END = '    </application>';
+const PREFIXES = ['android', 'tools'];
 
-// The links of app.urlSchemes the activity opens, from a browser as well, before the end of the activity's element.
+// A manifest's text without its comments, removed until none is left, as removing one may join others into one.
+function withoutComments(text) {
+    let current = text;
+    let previous;
+    do {
+        previous = current;
+        current = current.replace(/<!--[\s\S]*?-->/g, '');
+    } while (current !== previous);
+    return current;
+}
+
+function manifestParts(name, file) {
+    const text = withoutComments(fs.readFileSync(file, 'utf8').replace(/<\?xml[\s\S]*?\?>/, ''));
+    const root = /^\s*<manifest\b([^>]*)>([\s\S]*)<\/manifest>\s*$/.exec(text);
+    if (!root) throw new Error(`crossbind: the extension ${name}'s manifest ${file} is no <manifest> of elements, as an AndroidManifest.xml is.`);
+    const other = [...root[1].matchAll(/xmlns:([\w-]+)/g)].map(([, prefix]) => prefix).find((prefix) => !PREFIXES.includes(prefix));
+    if (other) throw new Error(`crossbind: the extension ${name}'s manifest ${file} declares the prefix ${other}, which the app's has not: it takes android and tools.`);
+    const attribute = [...root[1].matchAll(/([\w:.-]+)\s*=/g)].map(([, key]) => key).find((key) => !key.startsWith('xmlns'));
+    if (attribute) throw new Error(`crossbind: the extension ${name}'s manifest ${file} gives its <manifest> ${attribute}, which is the app's own.`);
+    // The permissions it asks for are those its permissions list, which the app asks for once each.
+    if (/<uses-permission[\s/>]/.test(root[2])) {
+        throw new Error(`crossbind: the extension ${name}'s manifest ${file} asks for a permission with <uses-permission>, which its app.android.permissions lists, as the app asks for each once.`);
+    }
+    const applications = [...root[2].matchAll(/<application\b([^>]*?)(?:\/>|>([\s\S]*?)<\/application>)/g)];
+    if (applications.length > 1) throw new Error(`crossbind: the extension ${name}'s manifest ${file} holds ${applications.length} <application> elements, of which it takes one.`);
+    const [application] = applications;
+    if (application && application[1].trim() !== '') {
+        throw new Error(`crossbind: the extension ${name}'s manifest ${file} gives its <application> attributes, which are the app's own: it holds what the extension adds to the app's alone.`);
+    }
+    return { manifest: application ? root[2].replace(application[0], '') : root[2], application: application?.[2] ?? '' };
+}
+
+// An extension's elements, as the app's manifest holds them, at the indentation of their place there.
+function indented(text, indent) {
+    const lines = text.split('\n').filter((line, index, all) => line.trim() !== '' || (index > all.findIndex((one) => one.trim() !== '')
+        && index < all.findLastIndex((one) => one.trim() !== '')));
+    const margin = Math.min(...lines.filter((line) => line.trim() !== '').map((line) => /^[ \t]*/.exec(line)[0].length));
+    return lines.map((line) => (line.trim() === '' ? '' : `${indent}${line.slice(margin).trimEnd()}`)).join('\n');
+}
+
+// What the activity opens, from a browser or a file manager as well, before the end of the activity's element.
 const ACTIVITY_END = '        </activity>';
-const urlFilter = (schemes) => [
-    '            <intent-filter>',
+const viewFilter = (data, isVerified = false) => [
+    `            <intent-filter${isVerified ? ' android:autoVerify="true"' : ''}>`,
     '                <action android:name="android.intent.action.VIEW" />',
     '                <category android:name="android.intent.category.DEFAULT" />',
     '                <category android:name="android.intent.category.BROWSABLE" />',
-    ...schemes.map((scheme) => `                <data android:scheme="${scheme}" />`),
+    ...data.map((attributes) => `                <data ${attributes} />`),
     '            </intent-filter>',
 ].join('\n');
+// The links of the app's schemes.
+const urlFilter = (schemes) => viewFilter(schemes.map((scheme) => `android:scheme="${scheme}"`));
+// The files of the app's types, which other apps hand it as content: addresses alone, as a file: one would have the app
+// read its own: by their MIME types, as Android matches what a content provider gives, else by their names' extensions,
+// which a provider's path shows or not; .*\\. takes one dot, and Android's pattern a single match.
+const fileFilters = (fileTypes) => fileTypes.map(({ extensions, mimeTypes }) => viewFilter(['android:scheme="content"', ...(mimeTypes.length > 0
+    ? mimeTypes.map((mime) => `android:mimeType="${mime}"`)
+    : ['android:host="*"', 'android:mimeType="*/*"', ...extensions.flatMap((ending) => [`android:pathPattern=".*\\\\.${ending}"`, `android:pathPattern=".*\\\\..*\\\\.${ending}"`])])]));
+// The https links of app.links, which Android verifies against each site's assetlinks.json.
+const linkFilters = (links) => links.map((link) => {
+    const { host, path: prefix } = appLinkParts(link);
+    return viewFilter(['android:scheme="https"', `android:host="${host}"`, ...(prefix ? [`android:pathPrefix="${prefix}"`] : [])], true);
+});
 
-const buildGradle = ({ id, label, version, abis, icon, launchMode, theme }) => `// crossbind writes this project anew on every build: the module comes prebuilt in src/main/jniLibs/, and the app's
+// The app's quick actions, Android's static shortcuts of its icon, which shows the app's icon beside each, or the
+// launcher's own without one: Android empties a static shortcut's task first, so a tap starts the host's trampoline,
+// which hands it to the activity that runs, with its page. Each label is a resource, as Android takes none other.
+const SHORTCUTS_META = '            <meta-data android:name="android.app.shortcuts" android:resource="@xml/shortcuts" />';
+const shortcutsXml = (items, id, icon) => `<?xml version="1.0" encoding="utf-8"?>
+<shortcuts xmlns:android="http://schemas.android.com/apk/res/android">
+${items.map(({ type }, index) => [
+        `    <shortcut android:shortcutId="${type}"${icon ? ` android:icon="${icon}"` : ''} android:shortcutShortLabel="@string/crossbind_shortcut_${index}">`,
+        `        <intent android:action="dev.crossbind.app.SHORTCUT" android:targetPackage="${id}" android:targetClass="dev.crossbind.app.CrossbindShortcutActivity">`,
+        // Android reads an extra's value of digits, or true or false, as a number or a boolean: after a prefix, each is text.
+        `            <extra android:name="dev.crossbind.app.shortcut" android:value="type:${type}" />`,
+        '        </intent>',
+        '    </shortcut>',
+    ].join('\n')).join('\n')}
+</shortcuts>
+`;
+// Text as a string resource holds it as it is: XML's escapes, and a backslash before what aapt reads otherwise, a quote,
+// an apostrophe, a backslash and an @ or a ? that starts it after any space; formatted="false" keeps a % as it is.
+const androidText = (text) => text.replace(/[\\'"]/g, '\\$&').replace(/^(\s*)([@?])/, '$1\\$2').replace(/&/g, '&amp;').replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+const shortcutLabels = (items) => `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+${items.map(({ title }, index) => `    <string name="crossbind_shortcut_${index}" formatted="false">${androidText(title)}</string>`).join('\n')}
+</resources>
+`;
+
+// The class of each extension's Java, which the activity calls by the extension's name, in the extensions' order.
+const extensionsJava = (java) => `// crossbind writes this file from the app's extensions: the class of each one's Java, under its name, and the holder of
+// each of the host's roles it holds.
+package dev.crossbind.app;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+final class Extensions {
+    // In the order of the app's extensions, in which each hears what the activity does.
+    static final Map<String, Extension> ALL;
+    // By the role, as page-dialogs, whose requests the activity hands its holder's Java.
+    static final Map<String, Extension> ROLES;
+
+    static {
+        Map<String, Extension> all = new LinkedHashMap<>();${java.map(({ name, className }) => `
+        all.put(${JSON.stringify(name)}, new ${className}());`).join('')}
+        ALL = Collections.unmodifiableMap(all);
+        Map<String, Extension> roles = new HashMap<>();${java.flatMap(({ name, roles = [] }) => roles.map((role) => `
+        roles.put(${JSON.stringify(role)}, all.get(${JSON.stringify(name)}));`)).join('')}
+        ROLES = Collections.unmodifiableMap(roles);
+    }
+
+    private Extensions() {}
+}
+`;
+
+const buildGradle = ({ id, label, version, abis, icon, launchMode, theme, libraries = [] }) => `// crossbind writes this project anew on every build: the module comes prebuilt in src/main/jniLibs/, and the app's
 // files are in src/main/assets/app/.
 plugins {
     id 'com.android.application'
@@ -133,26 +259,62 @@ dependencies {
         }
     }
     implementation 'androidx.webkit:webkit:${ANDROIDX_WEBKIT}'
-}
+${libraries.map((library) => `    implementation '${library}'\n`).join('')}}
 `;
 
 // An Android app as a Gradle project, written anew from the parts its ABI targets built: each brings its libraries,
-// the first also the app's files. Gradle adds Hermes and androidx.webkit from Maven, and makes the APK or the bundle.
-// The icons given are the files of the app's launcher icon under res/; without them it has the system's.
-export default function writeGradleProject(to, { parts, id, label, version, icons = null, urlSchemes = [], background = null, permissions = [] }) {
+// the first also the app's files. Gradle adds Hermes, androidx.webkit and its extensions' libraries from Maven, and makes
+// the APK or the bundle.
+// The icons given are the files of the app's launcher icon under res/; without them it has the system's. Each of java
+// is an extension's folder of Java sources, by package, which the app's sources take beside the activity, and the
+// class in it the activity calls.
+export default function writeGradleProject(to, {
+    parts, id, label, version, icons = null, urlSchemes = [], fileTypes = [], links = [], shortcutItems = [], background = null, permissions = [],
+    java = [], extensionPermissions = [], manifests = [], resources = [], maven = [],
+}) {
     const { name } = state.config.general;
     if (parts.length === 0) throw new Error(`crossbind: no part of the Android app ${name} is built, so there is no Gradle project to write.`);
+    // What the extensions add is read before the project goes, which a manifest crossbind refuses then leaves as it was.
+    const added = manifests.map(({ name: extension, file }) => manifestParts(extension, file));
+    // An app whose extensions ask Maven for libraries checks every file Gradle resolves, which it then resolves online.
+    const verification = maven.length > 0 ? mergedVerification(
+        fs.readFileSync(path.join(resolveAppHostRoot(), 'android-verification-metadata.xml'), 'utf8'),
+        maven.map(({ name: extension, verification: file }) => ({ name: extension, xml: fs.readFileSync(file, 'utf8') })),
+    ) : null;
     fs.rmSync(to, { recursive: true, force: true });
     fs.cpSync(path.join(resolveAppHostRoot(), 'android'), to, { recursive: true });
+    if (verification) fs.writeFileSync(path.join(to, 'gradle', 'verification-metadata.xml'), verification);
     const main = path.join(to, 'app', 'src', 'main');
     const manifest = path.join(main, 'AndroidManifest.xml');
     const text = fs.readFileSync(manifest, 'utf8');
-    if (!text.includes(ACTIVITY_END) || !text.includes(INTERNET)) {
+    if (!text.includes(ACTIVITY_END) || !text.includes(INTERNET) || !text.includes(APPLICATION_END)) {
         throw new Error(`crossbind: ${manifest}, from the app host, has no activity or permissions to give app.urlSchemes and app.permissions: update @crossbind/core-app-host to match crossbind.`);
     }
+    const own = (key, indent) => added.map((part) => part[key]).filter((part) => part.trim() !== '').map((part) => indented(part, indent));
+    // A replacer, as the extensions' text may hold what a replacement string reads as a pattern, as $&.
     fs.writeFileSync(manifest, text
-        .replace(INTERNET, [INTERNET, ...usesPermissions(permissions)].join('\n'))
-        .replace(ACTIVITY_END, urlSchemes.length > 0 ? `${urlFilter(urlSchemes)}\n${ACTIVITY_END}` : ACTIVITY_END));
+        .replace(INTERNET, () => [INTERNET, ...usesPermissions(permissions, extensionPermissions), ...own('manifest', '    ')].join('\n'))
+        .replace(ACTIVITY_END, () => [
+            ...(urlSchemes.length > 0 ? [urlFilter(urlSchemes)] : []), ...fileFilters(fileTypes), ...linkFilters(links),
+            ...(shortcutItems.length > 0 ? [SHORTCUTS_META] : []), ACTIVITY_END,
+        ].join('\n'))
+        .replace(APPLICATION_END, () => [...own('application', '        '), APPLICATION_END].join('\n')));
+    fs.writeFileSync(path.join(main, 'java', 'dev', 'crossbind', 'app', 'Extensions.java'), extensionsJava(java));
+    // The Java and Kotlin sources of an extension's folder alone, which may hold its manifest and resources as well: the
+    // Android Gradle plugin compiles Kotlin beside the Java.
+    java.forEach(({ name: extension, dir }) => {
+        const sources = path.join(main, 'java');
+        const files = fs.readdirSync(dir, { recursive: true }).filter((file) => /\.(java|kt)$/.test(file) && fs.statSync(path.join(dir, file), { throwIfNoEntry: false })?.isFile());
+        files.forEach((file) => {
+            if (fs.existsSync(path.join(sources, file))) {
+                throw new Error(`crossbind: the extension ${extension} has ${file} in its Java, which the app's Gradle project has already.`);
+            }
+        });
+        files.forEach((file) => {
+            fs.mkdirSync(path.dirname(path.join(sources, file)), { recursive: true });
+            fs.copyFileSync(path.join(dir, file), path.join(sources, file));
+        });
+    });
     parts.forEach(({ arch, dir }) => fs.cpSync(path.join(dir, 'lib'), path.join(main, 'jniLibs', arch), { recursive: true }));
     // A release keeps its libraries as linked beside the stripped ones it ships, for Google Play's crash reports.
     parts.filter(({ dir }) => fs.existsSync(path.join(dir, 'symbols')))
@@ -166,9 +328,27 @@ export default function writeGradleProject(to, { parts, id, label, version, icon
     }
     fs.mkdirSync(path.join(main, 'res', 'values'), { recursive: true });
     fs.writeFileSync(path.join(main, 'res', 'values', 'background.xml'), backgroundValues(background));
+    fs.writeFileSync(path.join(main, 'res', 'values', 'permissions.xml'), permissionValues(permissions));
+    if (shortcutItems.length > 0) {
+        fs.mkdirSync(path.join(main, 'res', 'xml'), { recursive: true });
+        fs.writeFileSync(path.join(main, 'res', 'xml', 'shortcuts.xml'), shortcutsXml(shortcutItems, id, icons ? '@mipmap/ic_launcher' : null));
+        fs.writeFileSync(path.join(main, 'res', 'values', 'shortcuts.xml'), shortcutLabels(shortcutItems));
+    }
+    // An extension's resources join the app's, of which they replace none.
+    resources.forEach(({ name: extension, dir }) => {
+        fs.readdirSync(dir, { recursive: true }).forEach((file) => {
+            const into = path.join(main, 'res', file);
+            if (fs.existsSync(into) && !fs.statSync(into).isDirectory()) {
+                throw new Error(`crossbind: the extension ${extension} has ${file} in its resources, which the app's Gradle project has already.`);
+            }
+        });
+        fs.cpSync(dir, path.join(main, 'res'), { recursive: true });
+    });
     fs.writeFileSync(path.join(to, 'app', 'build.gradle'), buildGradle({
         id, label, version, abis: parts.map(({ arch }) => arch), icon: icons ? '@mipmap/ic_launcher' : '@android:drawable/sym_def_app_icon',
-        launchMode: urlSchemes.length > 0 ? 'singleTask' : 'standard', theme: background ? '@style/CrossbindBackground' : DAY_NIGHT,
+        launchMode: urlSchemes.length + fileTypes.length + links.length + shortcutItems.length > 0 ? 'singleTask' : 'standard',
+        theme: background ? '@style/CrossbindBackground' : DAY_NIGHT,
+        libraries: [...new Set(maven.flatMap(({ coordinates }) => coordinates))],
     }));
     return to;
 }