crossbind 2.0.0-beta.67 → 2.0.0-beta.69

package/src/app/index.js

@@ -1,15 +1,7 @@
-// What an app's host does for its page: the dialogs that pick files or show a message, opening an address or a file
-// outside the app, the app's folders, quitting, its menus, its tray icon and notifications, the events of the app's
-// native code and a desktop app's updates. Each call goes to the host of an app (target.runtimeEnv: 'app'); in any
-// other build it rejects, or events.on throws. The app's native code calls the same through <crossbind/app.h>, but for
-// the menus, the tray, notifications and events.on.
-
-const OPEN = { title: 'string', defaultPath: 'string', filters: 'filters', directory: 'boolean', multiple: 'boolean' };
-const SAVE = { title: 'string', defaultPath: 'string', defaultName: 'string', filters: 'filters' };
-const MESSAGE = { message: 'string', detail: 'string', kind: 'string', buttons: 'buttons' };
-const MESSAGE_KINDS = ['info', 'warning', 'error'];
-// Android's dialogs take three buttons at most.
-const MAX_BUTTONS = 3;
+// What an app's host does for its page: the app's folders, quitting, its windows, the events of the app's native code and
+// the functions of its extensions, by their names. Each call goes to the host of an app (target.runtimeEnv: 'app'); in any
+// other build it rejects, or events.on throws. A page imports these from crossbind/app, which an app's bundler plugin
+// takes from the app host, with what crossbind's own extensions give the page, as crossbind/app/core alone holds these.
 
 // The app's crossbind.js, which initNative() loads, hands the calls to the host.
 function hostOf(member, name) {
@@ -22,207 +14,124 @@ function hostOf(member, name) {
 
 const call = (name, options) => hostOf('app', name)(name, options);
 
-const isFilters = (value) => Array.isArray(value) && value.every((filter) => typeof filter?.name === 'string'
-    && Array.isArray(filter.extensions) && filter.extensions.every((extension) => typeof extension === 'string'));
-
-// Spread reads a hole as undefined, which every() skips.
-const isButtons = (value) => Array.isArray(value) && value.length >= 1 && value.length <= MAX_BUTTONS
-    && [...value].every((label) => typeof label === 'string' && label !== '');
-
-// The lists an option may be, beside what typeof tells: how each is checked, and what it is called.
-const LISTS = {
-    filters: { isFitting: isFilters, name: 'list of { name, extensions }' },
-    buttons: { isFitting: isButtons, name: 'list of one to three labels' },
-    list: { isFitting: Array.isArray, name: 'list' },
-};
-
-// The options as the host takes them, so a misspelt or mistyped one fails here, saying which.
-function checked(name, options, kinds) {
+// The options as the host takes them, so a misspelt or mistyped one fails here, saying which: each key's kind is what
+// typeof gives, or { isFitting, name } for a list or an object, how it is checked and what it is called.
+export function checkedOptions(name, options, kinds) {
     const keys = Object.keys(kinds).join(', ');
     if (options === null || typeof options !== 'object' || Array.isArray(options)) {
         throw new TypeError(`crossbind: ${name} takes an object of ${keys}.`);
     }
     for (const [key, value] of Object.entries(options)) {
         if (!Object.hasOwn(kinds, key)) throw new TypeError(`crossbind: ${name} takes ${keys}; ${key} is none of them.`);
-        const list = LISTS[kinds[key]];
-        if (value !== undefined && !(list ? list.isFitting(value) : typeof value === kinds[key])) {
-            throw new TypeError(`crossbind: ${name}'s ${key} is no ${list ? list.name : kinds[key]}.`);
-        }
-    }
-    return options;
-}
-
-function checkedMessage(options) {
-    checked('dialog.message', options, MESSAGE);
-    if (!options.message) throw new TypeError('crossbind: dialog.message takes a message.');
-    if (options.kind !== undefined && !MESSAGE_KINDS.includes(options.kind)) {
-        throw new TypeError(`crossbind: dialog.message's kind is info, warning or error, not ${JSON.stringify(options.kind)}.`);
+        const kind = kinds[key];
+        const isOfKind = typeof kind === 'string' ? typeof value === kind : kind.isFitting(value);
+        if (value !== undefined && !isOfKind) throw new TypeError(`crossbind: ${name}'s ${key} is no ${typeof kind === 'string' ? kind : kind.name}.`);
     }
     return options;
 }
 
-function checkedPath(name, path) {
-    if (typeof path !== 'string' || !path) throw new TypeError(`crossbind: ${name} takes a path.`);
-    return { path };
-}
-
-// A menu of the bar is { label, items } or a standard one by its role. An item is { label, id, accelerator, enabled,
-// checked }, a submenu { label, items }, { type: 'separator' }, or a standard item by its role, which a label may
-// rename and, but for an editing one, which keeps the platform's keys, an accelerator change.
-const MENU_ROLES = ['editMenu', 'windowMenu'];
-const EDITING_ROLES = ['undo', 'redo', 'cut', 'copy', 'paste', 'selectAll'];
-const ITEM_ROLES = [...EDITING_ROLES, 'minimize', 'close', 'quit'];
-const ITEM_KINDS = {
-    label: 'string', id: 'string', accelerator: 'string', enabled: 'boolean', checked: 'boolean', items: 'list', role: 'string', type: 'string',
+// A window's options, as windows.open() takes them, and those windows.set() changes: sizes and places in logical pixels.
+// A window opens in the middle of the screen without x and y, and set() moves one there with center.
+const WINDOW_SIZES = ['width', 'height', 'minWidth', 'minHeight', 'maxWidth', 'maxHeight'];
+const WINDOW_SHARED = {
+    title: 'string', width: 'number', height: 'number', x: 'number', y: 'number', minWidth: 'number', minHeight: 'number',
+    maxWidth: 'number', maxHeight: 'number', resizable: 'boolean', alwaysOnTop: 'boolean', fullscreen: 'boolean',
 };
-const MODIFIERS = ['CmdOrCtrl', 'Ctrl', 'Alt', 'Shift'];
-const KEY = /^([A-Z0-9]|F([1-9]|1[0-2])|Enter|Escape|Tab|Space|Backspace|Delete|Up|Down|Left|Right|Home|End|PageUp|PageDown|Plus|Minus|Comma|Period)$/;
-
-// Typing uses neither a key with CmdOrCtrl, Ctrl or Alt nor a function key.
-function checkAccelerator(accelerator, where) {
-    const modifiers = accelerator.split('+');
-    const key = modifiers.pop();
-    const isKnown = KEY.test(key) && modifiers.every((modifier) => MODIFIERS.includes(modifier)) && new Set(modifiers).size === modifiers.length;
-    if (!isKnown || !(/^F\d+$/.test(key) || modifiers.some((modifier) => modifier !== 'Shift'))) {
-        throw new TypeError(`crossbind: menu.set's ${where}.accelerator ${JSON.stringify(accelerator)} is none, which is a key with CmdOrCtrl, Ctrl or Alt and maybe Shift, joined by +, as CmdOrCtrl+Shift+O is, or F1 to F12, alone or with any of them.`);
+const WINDOW_SET = { ...WINDOW_SHARED, center: 'boolean' };
+const WINDOW_OPEN = {
+    ...WINDOW_SHARED, path: 'string', name: 'string', backgroundColor: 'string', frame: 'boolean', parent: 'number', modal: 'boolean',
+};
+const MAX_WINDOW_SIZE = 16384;
+const MAX_WINDOW_PLACE = 1000000;
+// The size a window opens at without one.
+const WINDOW_SIZE = { width: 1024, height: 768 };
+const COLOR = /^#[0-9a-f]{6}$/i;
+
+const isWindowId = (id) => Number.isSafeInteger(id) && id >= 1;
+
+function checkedWindow(name, options, kinds) {
+    checkedOptions(name, options, kinds);
+    const least = name === 'windows.set' ? 0 : 1;
+    for (const key of WINDOW_SIZES) {
+        const size = options[key];
+        // A limit of 0 that windows.set() gives takes it away.
+        const isFitting = Number.isInteger(size) && size >= ((key === 'width' || key === 'height') ? 1 : least) && size <= MAX_WINDOW_SIZE;
+        if (size !== undefined && !isFitting) throw new TypeError(`crossbind: ${name}'s ${key} is no whole number of pixels up to ${MAX_WINDOW_SIZE}.`);
     }
-}
-
-function checkMenuItem(item, where, isMenu) {
-    if (item === null || typeof item !== 'object' || Array.isArray(item)) throw new TypeError(`crossbind: menu.set's ${where} is no object.`);
-    for (const [key, value] of Object.entries(item)) {
-        if (!Object.hasOwn(ITEM_KINDS, key)) throw new TypeError(`crossbind: menu.set's ${where} takes ${Object.keys(ITEM_KINDS).join(', ')}; ${key} is none of them.`);
-        const kind = ITEM_KINDS[key];
-        if (value !== undefined && !(kind === 'list' ? Array.isArray(value) : typeof value === kind)) {
-            throw new TypeError(`crossbind: menu.set's ${where}.${key} is no ${kind}.`);
+    for (const key of ['x', 'y']) {
+        const place = options[key];
+        if (place !== undefined && !(Number.isInteger(place) && Math.abs(place) <= MAX_WINDOW_PLACE)) {
+            throw new TypeError(`crossbind: ${name}'s ${key} is no whole number of pixels from -${MAX_WINDOW_PLACE} to ${MAX_WINDOW_PLACE}.`);
         }
     }
-    const has = (...keys) => keys.filter((key) => item[key] !== undefined);
-    const refuse = (what) => {
-        throw new TypeError(`crossbind: menu.set's ${where} ${what}.`);
-    };
-    if (item.type !== undefined) {
-        if (item.type !== 'separator' || isMenu || has(...Object.keys(ITEM_KINDS)).length > 1) refuse("is no separator, which is { type: 'separator' } alone, inside a menu");
-    } else if (item.role !== undefined) {
-        const roles = isMenu ? MENU_ROLES : [...ITEM_ROLES, ...MENU_ROLES];
-        if (!roles.includes(item.role)) refuse(`has no role ${JSON.stringify(item.role)}, which is one of ${roles.join(', ')}`);
-        if (MENU_ROLES.includes(item.role) && has('id', 'accelerator', 'enabled', 'checked', 'items').length > 0) refuse('is a standard menu, which takes a label alone');
-        if (EDITING_ROLES.includes(item.role) && item.accelerator !== undefined) refuse("is an editing item, which keeps the platform's keys and takes a label alone");
-        if (has('id', 'enabled', 'checked', 'items').length > 0) refuse('has a role, which takes a label and an accelerator alone');
-    } else if (!item.label) {
-        refuse('has no label');
-    } else if (item.items !== undefined) {
-        if (has('id', 'accelerator', 'enabled', 'checked').length > 0) refuse('is a menu, which takes a label and items alone');
-        // entries() reads a hole as undefined, which forEach skips.
-        for (const [index, child] of item.items.entries()) checkMenuItem(child, `${where}.items[${index}]`, false);
-    } else if (isMenu) {
-        refuse('is a menu, which takes a label and items, or the role editMenu or windowMenu');
+    if ((options.x === undefined) !== (options.y === undefined)) throw new TypeError(`crossbind: ${name} takes x and y together.`);
+    const { path, backgroundColor, parent } = options;
+    if (path !== undefined && (!path.startsWith('/') || path.startsWith('//') || path.split(/[?#]/, 1)[0].split('/').some((part) => DOT_PART.test(part) || part.includes('\\')))) {
+        throw new TypeError(`crossbind: ${name}'s path ${JSON.stringify(path)} is no path of the app's own pages, as /settings.html is.`);
     }
-    if (item.accelerator !== undefined) checkAccelerator(item.accelerator, where);
-}
-
-function checkedMenus(menus) {
-    if (!Array.isArray(menus)) throw new TypeError('crossbind: menu.set takes a list of menus.');
-    for (const [index, item] of menus.entries()) checkMenuItem(item, `menus[${index}]`, true);
-    return { menus };
+    if (backgroundColor !== undefined && !COLOR.test(backgroundColor)) throw new TypeError(`crossbind: ${name}'s backgroundColor is no color of the form #rrggbb.`);
+    if (parent !== undefined && !isWindowId(parent)) throw new TypeError(`crossbind: ${name}'s parent is no window's id.`);
+    if (options.modal && parent === undefined) throw new TypeError(`crossbind: ${name} opens a modal window above a parent: give it parent, the id of a window.`);
+    if (name === 'windows.open') checkedLimits(options);
+    return options;
 }
 
-// A tray item is { label, id, enabled, checked }, a submenu { label, items } or { type: 'separator' }: a tray's menu has
-// no keys, and no standard item.
-const TRAY = { tooltip: 'string', menu: 'list' };
-const TRAY_ITEM = { label: 'string', id: 'string', enabled: 'boolean', checked: 'boolean', items: 'list', type: 'string' };
-const NOTIFICATION = { title: 'string', body: 'string' };
-
-function checkTrayItem(item, where) {
-    const refuse = (what) => {
-        throw new TypeError(`crossbind: tray.set's ${where} ${what}.`);
-    };
-    if (item === null || typeof item !== 'object' || Array.isArray(item)) refuse('is no object');
-    for (const [key, value] of Object.entries(item)) {
-        if (!Object.hasOwn(TRAY_ITEM, key)) refuse(`takes ${Object.keys(TRAY_ITEM).join(', ')}; ${key} is none of them`);
-        const kind = TRAY_ITEM[key];
-        if (value !== undefined && !(kind === 'list' ? Array.isArray(value) : typeof value === kind)) refuse(`.${key} is no ${kind}`);
+// The limits of a window that opens, as app.window takes them: those of one that resizes, around the size it opens at.
+function checkedLimits(options) {
+    const limits = ['minWidth', 'minHeight', 'maxWidth', 'maxHeight'].filter((key) => options[key] !== undefined);
+    if (options.resizable === false && limits.length > 0) {
+        throw new TypeError(`crossbind: windows.open's ${limits.join(', ')} limit a window that resizes: drop them, or leave resizable true.`);
     }
-    const others = Object.keys(item).filter((key) => key !== 'type' && item[key] !== undefined);
-    if (item.type !== undefined) {
-        if (item.type !== 'separator' || others.length > 0) refuse("is no separator, which is { type: 'separator' } alone");
-    } else if (!item.label) {
-        refuse('has no label');
-    } else if (item.items !== undefined) {
-        if (others.some((key) => key !== 'label' && key !== 'items')) refuse('is a menu, which takes a label and items alone');
-        // entries() reads a hole as undefined, which forEach skips.
-        for (const [index, child] of item.items.entries()) checkTrayItem(child, `${where}.items[${index}]`);
+    for (const [size, side] of [['width', 'Width'], ['height', 'Height']]) {
+        const opensAt = options[size] ?? WINDOW_SIZE[size];
+        if (options[`min${side}`] > opensAt) throw new TypeError(`crossbind: windows.open's min${side} is above the ${size} the window opens at, ${opensAt}.`);
+        if (options[`max${side}`] < opensAt) throw new TypeError(`crossbind: windows.open's max${side} is below the ${size} the window opens at, ${opensAt}.`);
     }
 }
 
-function checkedTray(options) {
-    checked('tray.set', options, TRAY);
-    for (const [index, item] of (options.menu ?? []).entries()) checkTrayItem(item, `menu[${index}]`);
-    return options;
-}
-
-function checkedNotification(options) {
-    checked('notification.show', options, NOTIFICATION);
-    if (!options.title) throw new TypeError('crossbind: notification.show takes a title.');
-    return options;
+// The window a call names by its id, or with none the calling page's own.
+function windowOf(name, id) {
+    if (id === undefined) return {};
+    if (!isWindowId(id)) throw new TypeError(`crossbind: ${name} takes the id of a window, as windows.open() gives it, or none for the page's own.`);
+    return { id };
 }
 
-export const dialog = {
-    // The paths of the files or folders the user picked, or null when they cancelled.
-    open: async (options = {}) => call('dialog.open', checked('dialog.open', options, OPEN)),
-    // The path the user chose to save to, or null when they cancelled.
-    save: async (options = {}) => call('dialog.save', checked('dialog.save', options, SAVE)),
-    // The index of the button the user clicked: Return gives the first, and Escape or closing the dialog the last.
-    message: async (options) => call('dialog.message', checkedMessage(options)),
-};
-
-export const shell = {
-    // An http, https or mailto address in the default browser or mail app.
-    openExternal: async (url) => {
-        if (typeof url !== 'string' && !(url instanceof URL)) throw new TypeError('crossbind: shell.openExternal takes an address.');
-        return call('shell.openExternal', { url: String(url) });
-    },
-    // A file in the app the system opens its kind with. Opening a program runs it, and a script in the page could ask for
-    // any path, so the host opens files where app.openPath in crossbind.config.js lets it alone; native code opens any.
-    openPath: async (path) => call('shell.openPath', checkedPath('shell.openPath', path)),
-    // A file, selected, in the system's file manager: one in the app's folders, or one a dialog picked during this run.
-    revealInFolder: async (path) => call('shell.revealInFolder', checkedPath('shell.revealInFolder', path)),
-    // A file or folder moved to the system's trash, where its user can take it back: one in the app's folders, not one of
-    // them itself, or one a dialog picked during this run. Where the system has no trash, nothing moves.
-    trash: async (path) => call('shell.trash', checkedPath('shell.trash', path)),
-};
-
 export const app = {
     // The app's own folders, made when first asked for: { data, cache, logs }.
     paths: async () => call('app.paths', {}),
     // Ends the app as closing its window does.
     quit: async () => call('app.quit', {}),
+    // Asks the app's extensions, as its user's Quit does, then ends the app as quit() does, unless one keeps it running.
+    requestQuit: async () => call('app.requestQuit', {}),
     // Ends the app as quit() does, then opens it again, with no link.
     relaunch: async () => call('app.relaunch', {}),
-    // The links of app.urlSchemes that opened the app and have not reached the page yet, the one it was launched with
-    // among them; later ones come as the event open-url. Listening first, then asking, misses none.
-    launchUrls: async () => call('app.launchUrls', {}),
+    // The launch that started a desktop app: { args, cwd }, its arguments without the program's own and without the links
+    // of the app's schemes, and the folder it was launched in. A phone's has neither.
+    launchArgs: async () => call('app.launchArgs', {}),
 };
 
-export const menu = {
-    // Sets the app's menus: on macOS after its app menu, which the app keeps, and on Windows and Linux in a bar of its
-    // window. A click of an item with an id is an event, menu, of { id }, and of { id, checked } for an item it checked
-    // or unchecked; a standard item does what its role says.
-    set: async (menus) => call('menu.set', checkedMenus(menus)),
-};
-
-export const tray = {
-    // The app's icon in the macOS menu bar, the Windows notification area or a Linux desktop's status tray, with its
-    // tooltip and the menu a click opens. A click of an item with an id is the event menu, as one of menu.set's is, and a
-    // click of the icon the event tray where it opens no menu. Set again, it changes the icon that shows.
-    set: async (options = {}) => call('tray.set', checkedTray(options)),
-    // Takes the icon away.
-    remove: async () => call('tray.remove', {}),
-};
-
-export const notification = {
-    // A notification of the system's, with a title and a body; a click on it is the event notification.
-    show: async (options) => call('notification.show', checkedNotification(options)),
+export const windows = {
+    // Opens a window of the app's own page at path, '/' by default, in front: { id, ignored }, its id and the options the
+    // platform could not honour, which it opens without. A name already open brings that window to the front instead.
+    // The other functions name a window by its id, and with none the calling page's own.
+    open: async (options = {}) => call('windows.open', checkedWindow('windows.open', options, WINDOW_OPEN)),
+    // Changes an open window: { ignored }, as open() gives it.
+    set: async (id, options) => {
+        const [named, changes] = typeof id === 'object' && options === undefined ? [undefined, id] : [id, options];
+        return call('windows.set', { ...checkedWindow('windows.set', changes, WINDOW_SET), ...windowOf('windows.set', named) });
+    },
+    // Closes a window as its user does, which an extension may keep open.
+    close: async (id) => call('windows.close', windowOf('windows.close', id)),
+    // Brings a window to the front, restored if it was minimized.
+    focus: async (id) => call('windows.focus', windowOf('windows.focus', id)),
+    minimize: async (id) => call('windows.minimize', windowOf('windows.minimize', id)),
+    toggleMaximize: async (id) => call('windows.toggleMaximize', windowOf('windows.toggleMaximize', id)),
+    // Moves the page's window with the pointer, as its title bar does, from a mousedown of the primary button.
+    startDrag: async () => call('windows.startDrag', {}),
+    // The open windows, the oldest first, and the page's own: { id, name, title, x, y, width, height, isMaximized,
+    // isMinimized, isFullscreen, isFocused }.
+    list: async () => call('windows.list', {}),
+    current: async () => call('windows.current', {}),
 };
 
 export const events = {
@@ -233,13 +142,42 @@ export const events = {
         if (typeof listener !== 'function') throw new TypeError('crossbind: events.on takes a function to call.');
         return hostOf('on', 'events.on')(name, listener);
     },
+    // The values of the events of this name the app's native code held for the page with holdEvent(), which came before
+    // the page asked for them since it loaded; later ones come as the events while it listens. Listening first, then
+    // asking, misses none.
+    held: async (name) => {
+        if (typeof name !== 'string' || !name) throw new TypeError('crossbind: events.held takes the name of an event.');
+        return call('events.held', { name });
+    },
+};
+
+// A function of one of the app's extensions, by its name, as clipboard.readText, with options of JSON values and bytes,
+// a typed array, a DataView or an ArrayBuffer, whose result's bytes come back as a Uint8Array; an extension's own
+// package calls it so. The host checks the options. onMessage gets each message the function sends before it answers,
+// in order, all of them before invoke resolves; signal cancels the call, which then rejects with the signal's reason.
+export const invoke = async (name, options = {}, { onMessage, signal } = {}) => {
+    if (typeof name !== 'string' || !name) throw new TypeError("crossbind: invoke takes the name of one of the app's functions.");
+    if (onMessage !== undefined && typeof onMessage !== 'function') throw new TypeError('crossbind: invoke takes onMessage as a function.');
+    if (signal !== undefined && !(signal instanceof AbortSignal)) throw new TypeError('crossbind: invoke takes signal as an AbortSignal.');
+    const host = hostOf('app', name);
+    // An older host would leave them out without a word.
+    if (onMessage !== undefined || signal !== undefined) hostOf('takesMessages', 'invoke with onMessage or signal');
+    return host(name, options, { onMessage, signal });
 };
 
-// One check or install runs at a time, and another rejects meanwhile.
-export const updater = {
-    // The version app.updater.url in crossbind.config.js offers when it is newer than the app's, as { version }, or null.
-    check: async () => call('updater.check', {}),
-    // Downloads that version, checks that the key of app.updater.publicKey signed it and installs it in place of the app,
-    // which then quits and opens the new version. It rejects when that fails.
-    install: async () => call('updater.install', {}),
+const EXTENSION_NAME = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+// A part of a path the URL would resolve away, escaped or not, to another extension's or the page's own.
+const DOT_PART = /^(\.|%2e){1,2}$/i;
+const ANDROID_ORIGIN = 'https://appassets.androidplatform.net';
+
+// The URL of a path an extension's route serves, as "/clips/intro.mp4" or "/thumb/42?size=256", for the page's <img>,
+// <video> or fetch(), as the URL holds it: what a path takes escaped, the caller escapes. The route gets it decoded.
+// The app's own origin is an https one on Android, whose WebView serves no scheme of an app's.
+export const routeUrl = (extension, path) => {
+    if (typeof extension !== 'string' || !EXTENSION_NAME.test(extension)) throw new TypeError("crossbind: routeUrl takes the name of one of the app's extensions.");
+    if (typeof path !== 'string' || !path.startsWith('/')) throw new TypeError('crossbind: routeUrl takes a path that starts with "/".');
+    if (path.split(/[?#]/, 1)[0].split('/').some((part) => DOT_PART.test(part))) throw new TypeError('crossbind: routeUrl takes a path without a part "." or "..".');
+    const isAndroid = Boolean(globalThis.__crossbind_port) || globalThis.location?.origin === ANDROID_ORIGIN;
+    return `${isAndroid ? ANDROID_ORIGIN : 'crossbind://app'}/ext/${extension}${path}`;
 };
+

package/src/assets/toolchain-digests.json

@@ -1,55 +1,55 @@
 {
-    "version": "1.0.18",
+    "version": "1.0.20",
     "registry": "ghcr.io/crossbind",
     "toolchains": {
         "rust": "1.99.1"
     },
     "images": {
         "rust-sysroot": {
-            "index": "sha256:31a213289c4dc1125b462ef006cc27b84ee7eca4e3ef0a93259bd698d56c7359",
+            "index": "sha256:3f62871ccbebbdca53b798fa1b21173bee848ada7744f5108df66a290d3cca78",
             "platforms": {
-                "linux/arm64": "sha256:e82b9a4b9661356238b264a9d5b6921d364cbc81c54ec8426349527144b91bbc",
-                "linux/amd64": "sha256:33c63cb3ed60a6d771f079a60c97dfa1f183f215d4087bb655ff4deca2366d9a"
+                "linux/arm64": "sha256:ec7c2bba3add2385099b71520c5d68540e8dba691f57a42c0e9143ea5b8981df",
+                "linux/amd64": "sha256:dfad6e04d3168f5e7375aba271d0e615cc6658793527503ce3070efbd4ac5f91"
             }
         },
         "base": {
-            "index": "sha256:ca5b17d648e797193d7f3c67635e1e73e56b58d02699a55ea61a35eb5ca8d0c8",
+            "index": "sha256:a5c7ea17f3e13c13d3c9f53307cce95d037bbb6b58b08034cfa2cb8112a63407",
             "platforms": {
-                "linux/arm64": "sha256:48666c55a2f943d8be029080fab985839bc50231b8556a00100bc3702a7bcc51",
-                "linux/amd64": "sha256:847f3c686dc8a846b05ee76d38a79b9ac68fb293ca014d56967ee12859849f1f"
+                "linux/amd64": "sha256:a0934c868ccd5a09de14d193ae33b091ecfddf3c13548595e918c0b053e41dd6",
+                "linux/arm64": "sha256:14d4bcea7537972052cd6cee314a5c08f1cd68eebd3a7461ff7ca594994c49eb"
             }
         },
         "web": {
-            "index": "sha256:72cdc6f5b41d946edc7ca8cd5e1bcf7314f03dfc71be9067994b38130f965711",
+            "index": "sha256:00a19f61fa46315175be11f20cea051311c218ab6e99bd1bca70236415a69af9",
             "platforms": {
-                "linux/arm64": "sha256:6d1756fa994e5d939ac5696ebe32012f56c95d0428a8bc7b3775d53acbff8735",
-                "linux/amd64": "sha256:14aa215c2157e485ce6d664e0077a3cf6938733855b8146e97830e48fda13875"
+                "linux/arm64": "sha256:6e75223e8c696d93f5ab57e286425b4b94c4b1dcb3cf291e63c2820636dfa2a6",
+                "linux/amd64": "sha256:fe4e84f435838a35f2d60774be0050c39f2ecf1b8ed6cca23530b8c32f5c6211"
             }
         },
         "android": {
-            "index": "sha256:7cbd98594a1fb1f48fe156a21c6c5256cd535d2ffd152c1f80f2860d4dc5b6f0",
+            "index": "sha256:df5bf439ab81afbe28a166dcd3c0ec281aea11d4265b1fc24225cc686f643ce1",
             "platforms": {
-                "linux/amd64": "sha256:a6e99a0a66e038fd0e6d1154df6c7c58d68acd9def896b63f542d810d923bd87"
+                "linux/amd64": "sha256:d2f5460a998aa1695b04d0d1bc231af4d77dd78931ca0f2b02adec51a61f0c02"
             }
         },
         "android-app": {
-            "index": "sha256:5cfd1df40ae28730d592f76ade7e08e628f0002d73979015308d50727f021f3e",
+            "index": "sha256:d72766f41a7d0343fdf36a425a9c5e0ea7dda8ac6f3b2697fe49d79a21e5018b",
             "platforms": {
-                "linux/amd64": "sha256:98d035dfaeb27095d0a4edce83299ebbb3ffa8e360a4cb925db7cd0b0b8a4666"
+                "linux/amd64": "sha256:8e62eea8685cd28276dfdd28b34aa75b3a0a677b40a93ea3f28f7f3ef1565425"
             }
         },
         "linux": {
-            "index": "sha256:9114bdc0e6b2c1b753d2ba154181566c320e9a901030a14c707f174b7e4849f5",
+            "index": "sha256:a4828cf2821cc2313f5ddf5bc761073c90616fbef09daa8b8d93e7fa3050497a",
             "platforms": {
-                "linux/arm64": "sha256:47e104db909dc78a995733d3d27db94e135f1044e1f0860bb201930a65273af0",
-                "linux/amd64": "sha256:cd13e6b3f5c5303a583da5267531a83839fe8cf7979890463fc45a914a6d5d3f"
+                "linux/arm64": "sha256:501a878b581295d3946945dfa9bc98a0aa3de5d4c6bc006c7224756cccbf1e35",
+                "linux/amd64": "sha256:ee5a4f7ee23fdda7e50d4130d783a76d7c44d079ae34b4a326565510eea761dc"
             }
         },
         "windows": {
-            "index": "sha256:46e6da18313f4fd3b599fb2505383aa34f32ffe7ceb659426fa3fb71e6f1e8e7",
+            "index": "sha256:13fc02ab67d1465cbe75715d7de6a87c5319477eba2c0459c914bb5b698df766",
             "platforms": {
-                "linux/arm64": "sha256:b6457367be5c6863f8d336ce426b9dba7fdfa192308876e4bc390d82a6e18474",
-                "linux/amd64": "sha256:fd5bdc1f34d64bb9aebae1e1d44fc380c1dd815bd6686349e428d4551732f6e0"
+                "linux/amd64": "sha256:78883c59167af69c5b9433ef6cdfa35aab3833501bb85d830d95f24079a6c8d0",
+                "linux/arm64": "sha256:f27f09f8e661261c770976580d9861d4ce290eb1ac3030e6198f3c0a4987bd8a"
             }
         }
     }

package/src/bin.js

@@ -15,8 +15,13 @@ import buildWasiCommand from './actions/buildWasiCommand.js';
 import buildNode, { addonsInPackages, bundleNodeLoader, publishNodeData } from './actions/buildNode.js';
 import buildNativeCommand from './actions/buildNativeCommand.js';
 import buildApp, { appOutputPath, assertAppRunner, publishApp } from './actions/buildApp.js';
-import { releaseSigning } from './actions/androidGradle.js';
-import { UPDATER_KEY, newUpdaterKey } from './actions/appUpdate.js';
+import {
+    makeUploadKey, releaseSigningEnv, showUploadKeyPassword, useUploadKey,
+} from './actions/uploadKey.js';
+import publish, { publishHelp, publishersOf } from './actions/publish.js';
+import { iosDeviceOption } from './actions/iosDevice.js';
+import addExtension from './actions/addExtension.js';
+import addExtensionCommands from './actions/extensionCommands.js';
 import buildExternal from './actions/buildExternal.js';
 import buildPackageTypes from './actions/buildTypes.js';
 import buildLib from './actions/buildLib.js';
@@ -116,37 +121,85 @@ function projectVite() {
     }
 }
 
+// The project's Vite, as `crossbind app dev`, `build` and `publish` run it, and its exit code once it ends. A signal sent
+// to crossbind alone reaches Vite too, which ends through its exit hooks; Ctrl-C reaches both. Once Vite has ended,
+// signals stop crossbind again, as at the questions a publish asks after its build.
+function runVite(args, env) {
+    const vite = spawn(process.execPath, [projectVite(), ...args], { stdio: 'inherit', cwd: state.config.paths.project, env });
+    const forwards = ['SIGINT', 'SIGTERM', 'SIGHUP'].map((signal) => [signal, () => vite.kill(signal)]);
+    forwards.forEach(([signal, forward]) => process.prependListener(signal, forward));
+    return new Promise((resolve) => {
+        vite.on('exit', (code, signal) => {
+            forwards.forEach(([name, forward]) => process.off(name, forward));
+            resolve(code ?? 128 + os.constants.signals[signal]);
+        });
+    });
+}
+
+function assertAppProject() {
+    if (state.config.target.runtimeEnv !== 'app') {
+        throw new Error("crossbind: crossbind app builds an app, which this project is not: set target: { runtimeEnv: 'app' } in crossbind.config.js, as the desktop-app template does.");
+    }
+}
+
 const commandApp = program.command('app').description('build the project as an app, or open it on the dev server');
 [
     ['dev', 'open the app on the dev server, and open it anew as its native code changes'],
     ['build', 'build the app with its page: for Android also its APK, and with an upload key its bundle'],
-].forEach(([name, description]) => commandApp.command(name).description(description)
-    .addOption(new Option('-p, --platform <platform>', "the app's platform (default: CROSSBIND_APP_PLATFORM, else this machine's)").choices(APP_PLATFORMS))
-    // Vite's own options, as --port or --mode, go on to Vite.
+].forEach(([name, description]) => {
+    const appCommand = commandApp.command(name).description(description)
+        .addOption(new Option('-p, --platform <platform>', "the app's platform (default: CROSSBIND_APP_PLATFORM, else this machine's)").choices(APP_PLATFORMS));
+    if (name === 'dev') {
+        appCommand.option('--device [name]', 'open an iOS app on a connected iPhone or iPad, the one named or else the only one, rather than in the Simulator');
+    }
+    appCommand
+        // Vite's own options, as --port or --mode, go on to Vite.
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .action(async ({ platform, device }, command) => {
+            assertAppProject();
+            // An Android build checks its upload key before the native build, not after it.
+            const isAndroidBuild = name === 'build' && (platform ?? process.env.CROSSBIND_APP_PLATFORM) === 'android';
+            const { env: signing } = isAndroidBuild ? await releaseSigningEnv() : { env: {} };
+            const onDevice = device === undefined ? {} : { CROSSBIND_APP_DEVICE: iosDeviceOption(device, platform ?? process.env.CROSSBIND_APP_PLATFORM) };
+            const env = { ...process.env, ...signing, ...(platform ? { CROSSBIND_APP_PLATFORM: platform } : {}), ...onDevice };
+            process.exit(await runVite([...(name === 'build' ? ['build'] : []), ...command.args], env));
+        });
+});
+
+commandApp.command('upload-key')
+    .description("make this machine's upload key, which signs an Android app's bundle for Google Play")
+    .option('--use <keystore>', 'make a key you have the upload key instead, once it opens with its password')
+    .option('--alias <alias>', 'the alias of the key in the keystore --use names', 'upload')
+    .option('--no-keychain', 'keep the password in no keychain, so builds ask for it')
+    .option('--show-password', 'print the password the keychain keeps, for another machine or CI')
+    .action(async ({ use, alias, keychain, showPassword }) => {
+        if (showPassword) showUploadKeyPassword();
+        else if (use) await useUploadKey(use, { alias, isKeychain: keychain });
+        else await makeUploadKey({ isKeychain: keychain });
+    });
+
+commandApp.command('publish')
+    .usage('[store] [options]')
+    .description("build the app and send it to a store, as its publisher does, one of crossbind's own or of an extension's")
+    .addOption(new Option('-p, --platform <platform>', "the app's platform: without a store, the one that goes first for it (default: CROSSBIND_APP_PLATFORM, else for a store of desktop apps this machine's)").choices(APP_PLATFORMS))
+    .addHelpText('after', () => publishHelp(publishersOf(state.config?.extensions ?? [])))
+    // The store's own options, and Vite's, as --mode, which go on to Vite.
     .allowUnknownOption()
     .allowExcessArguments()
-    .action(({ platform }, command) => {
-        if (state.config.target.runtimeEnv !== 'app') {
-            throw new Error("crossbind: crossbind app builds an app, which this project is not: set target: { runtimeEnv: 'app' } in crossbind.config.js, as the desktop-app template does.");
-        }
-        // An Android build checks its upload key before the native build, not after it.
-        if (name === 'build' && (platform ?? process.env.CROSSBIND_APP_PLATFORM) === 'android') releaseSigning();
-        const vite = spawn(process.execPath, [projectVite(), ...(name === 'build' ? ['build'] : []), ...command.args], {
-            stdio: 'inherit',
-            cwd: state.config.paths.project,
-            env: platform ? { ...process.env, CROSSBIND_APP_PLATFORM: platform } : process.env,
-        });
-        // A signal sent to crossbind alone reaches Vite too, which ends through its exit hooks; Ctrl-C reaches both.
-        ['SIGINT', 'SIGTERM', 'SIGHUP'].forEach((signal) => process.prependListener(signal, () => vite.kill(signal)));
-        vite.on('exit', (code, signal) => process.exit(code ?? 128 + os.constants.signals[signal]));
-    }));
+    .action(async ({ platform }, command) => {
+        assertAppProject();
+        await publish(command.args, { platform, envPlatform: process.env.CROSSBIND_APP_PLATFORM, runVite });
+    });
+
+// crossbind app alone reads them, so that an extension's package that cannot be read stops no other command.
+if (process.argv[2] === 'app') addExtensionCommands(commandApp);
 
-commandApp.command('updater-key')
-    .description("make the key pair that signs a desktop app's updates")
-    .action(() => {
-        const { publicKey, privateKey } = newUpdaterKey();
-        console.log(`crossbind: app.updater.publicKey in crossbind.config.js: ${publicKey}`);
-        console.log(`crossbind: ${UPDATER_KEY}, kept secret where the app is built: ${privateKey}`);
+program.command('add')
+    .description("install an app extension's package with the project's package manager and list it in crossbind.config.js's extensions")
+    .argument('<package>', "the package as a package manager takes it: its name, name@version or a path to it")
+    .action((spec) => {
+        addExtension(spec, { config: state.config });
     });
 
 program.command('licenses')

package/src/index.js

@@ -6,8 +6,12 @@ export { default as buildWasm } from './actions/buildWasm.js';
 export {
     default as buildApp, buildProjectApp, publishApp, appLayout, appOutputName, appTargetParams,
 } from './actions/buildApp.js';
-export { checkInstaller } from './actions/appInstaller.js';
+export { checkInstaller, shipApp } from './actions/appInstaller.js';
+export { resolveAppPageApi } from './utils/resolveAppHost.js';
 export { default as openInSimulator, buildForSimulator } from './actions/iosSimulator.js';
+export {
+    default as openOnIosDevice, buildForIosDevice, connectedIosDevice, iosDeviceAddress, iosDevServer,
+} from './actions/iosDevice.js';
 export { default as openOnDevice, adbPath } from './actions/androidDevice.js';
 export { buildApk } from './actions/androidGradle.js';
 export { default as isSourceNewer } from './actions/isSourceNewer.js';