@coworkee/airworks 0.0.0-stage → 0.0.1023

package/README.md

@@ -1,3 +1,24 @@
-# Temporary Holding Version
+# @coworkee/airworks
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The [AirWorks](https://fgilde.github.io/AirWorks/) web desktop for apps built on [Coworkee](https://fgilde.github.io/CoworkeeLib/): sign-in through the app's BFF, theme, logo and texts of the app, realtime, and apps for profile, settings, files (with the MudEx file preview), data tables, chat, reports, reports with their designer, the AI assistant, notifications and the whole administration (users, roles, applications, themes, languages, translations, mail templates, campaigns, mail log, backups, audit log, ...).
+
+```bash
+npm install @coworkee/airworks @coworkee/client github:fgilde/AirWorks
+```
+
+```ts
+import { adminApps, defaultApps, useCoworkee } from '@coworkee/airworks';
+import { AirWorks } from '@fgilde/airworks';
+import '@fgilde/airworks/style.css';
+import '@coworkee/airworks/style.css';
+
+const coworkee = await useCoworkee(AirWorks, { title: 'Shop' });
+await coworkee.register(...defaultApps, ...adminApps);
+document.body.append(document.createElement('air-desktop'));
+```
+
+Apps are hidden when the user lacks their permission, like the menu of the Blazor app. `crudApp(...)` builds list apps with create, edit, delete and row actions; `coworkee.realtime.subscribe(topic, handler)` follows the realtime hub.
+
+`coworkee new --airworks` creates an app with this client in the Aspire app host; it takes the packages from the tarballs inside the template, or with `--airworks-packages npm` the version of the Coworkee release on npm. Documentation: [AirWorks client](https://fgilde.github.io/CoworkeeLib/web/airworks/)
+
+License: MIT

package/dist/apps/admin/identity.d.ts

@@ -0,0 +1,15 @@
+import type { Coworkee } from '../../coworkee.ts';
+import type { LookupSource } from '../../lookup.ts';
+/** Users searched and paged on the server, for pickers. */
+export declare const userLookup: ({ request }: Coworkee) => LookupSource;
+/** Groups searched and paged on the server, for pickers. */
+export declare const groupLookup: ({ request }: Coworkee) => LookupSource;
+/** The permissions of a role, user or group as one checkbox list per permission group. */
+export declare function editGrants(coworkee: Coworkee, providerType: 'Role' | 'User' | 'Group', key: string, title: string): Promise<boolean>;
+export declare const usersApp: (coworkee: Coworkee) => import("../../coworkee.ts").CoworkeeApp;
+export declare const groupsApp: (coworkee: Coworkee) => import("../../coworkee.ts").CoworkeeApp;
+export declare const rolesApp: (coworkee: Coworkee) => import("../../coworkee.ts").CoworkeeApp;
+export declare const clientsApp: (coworkee: Coworkee) => import("../../coworkee.ts").CoworkeeApp;
+export declare const scopesApp: (coworkee: Coworkee) => import("../../coworkee.ts").CoworkeeApp;
+export declare const apiKeysApp: (coworkee: Coworkee) => import("../../coworkee.ts").CoworkeeApp;
+export declare const identityApps: ((coworkee: Coworkee) => import("../../coworkee.ts").CoworkeeApp)[];

package/dist/apps/admin/identity.js

@@ -0,0 +1,256 @@
+import { choices, crudApp } from "../../crud.js";
+import { display, esc } from "../../dom.js";
+import { formDialog, infoDialog } from "../../form.js";
+const identity = '/api/v1/identity';
+const json = (method, body) => ({ method, body: body === undefined ? undefined : JSON.stringify(body) });
+const quiet = (promise, fallback) => promise.catch(() => fallback);
+const check = (value) => value ? '✓' : '';
+const roleChoices = async (coworkee) => choices(await quiet(coworkee.request(`${identity}/roles`), []), (role) => role.id, (role) => role.name);
+const pageOf = (page, text) => new URLSearchParams({ Page: String(page), PageSize: '20', Search: text });
+/** Users searched and paged on the server, for pickers. */
+export const userLookup = ({ request }) => ({
+    search: async (text, page) => {
+        const result = await request(`${identity}/users?${pageOf(page, text)}`);
+        return { items: result.items.map((user) => ({ value: user.id, label: user.email })), total: Number(result.totalCount) };
+    },
+    resolve: (ids) => request(`${identity}/users/names`, json('POST', { ids })),
+});
+/** Groups searched and paged on the server, for pickers. */
+export const groupLookup = ({ request }) => ({
+    search: async (text, page) => {
+        const result = await request(`${identity}/groups?${pageOf(page, text)}`);
+        return { items: result.items.map((group) => ({ value: group.id, label: group.name })), total: Number(result.totalCount) };
+    },
+});
+/** The permissions of a role, user or group as one checkbox list per permission group. */
+export async function editGrants(coworkee, providerType, key, title) {
+    const path = `${identity}/permissions/grants/${providerType}/${encodeURIComponent(key)}`;
+    const [groups, granted] = await Promise.all([coworkee.request(`${identity}/permissions/definitions`), coworkee.request(path)]);
+    const fields = groups.map((group) => ({ name: group.name, label: group.displayName, type: 'multi', options: group.permissions.map((p) => ({ value: p.name, label: coworkee.t(p.displayName) })) }));
+    const values = Object.fromEntries(groups.map((group) => [group.name, group.permissions.map((p) => p.name).filter((name) => granted.includes(name))]));
+    await formDialog(coworkee, {
+        title: `${coworkee.t('Permissions')} - ${title}`, fields, values,
+        onSubmit: (chosen) => coworkee.request(path, json('PUT', { names: Object.values(chosen).flat() })),
+    });
+    return false;
+}
+export const usersApp = crudApp({
+    id: 'coworkee.admin.users', group: 'Identity', title: 'Users', icon: 'startmenu-user.png', accent: '#1565c0', width: 920,
+    permissions: ['Identity.Users.View'],
+    search: true, serverSearch: true,
+    load: async ({ request }, { page, pageSize, search }) => {
+        const result = await request(`${identity}/users?${new URLSearchParams({ Page: String(page), PageSize: String(pageSize), Search: search })}`);
+        return { items: result.items, total: Number(result.totalCount) };
+    },
+    columns: [
+        { field: 'email', title: 'Email' },
+        { field: 'name', title: 'Name', format: (user) => [user.firstName, user.lastName].filter(Boolean).join(' ') },
+        { field: 'roles', title: 'Roles', format: (user) => user.roles.map((role) => role.name).join(', ') },
+        { field: 'isActive', title: 'Active', format: (user) => check(user.isActive), html: true },
+    ],
+    create: {
+        permission: 'Identity.Users.Manage',
+        values: { isActive: true },
+        fields: async (coworkee) => [
+            { name: 'email', label: 'Email', type: 'email', required: true },
+            { name: 'firstName', label: 'First name' }, { name: 'lastName', label: 'Last name' },
+            { name: 'password', label: 'Initial password', type: 'password' },
+            { name: 'mustChangePassword', label: 'Must change password', type: 'bool' },
+            { name: 'isActive', label: 'Active', type: 'bool' },
+            { name: 'roleIds', label: 'Roles', type: 'multi', options: await roleChoices(coworkee) },
+        ],
+        save: (values, { request }) => request(`${identity}/users`, json('POST', values)),
+    },
+    edit: {
+        permission: 'Identity.Users.Manage',
+        fields: async (coworkee) => [
+            { name: 'userName', label: 'User name' }, { name: 'firstName', label: 'First name' }, { name: 'lastName', label: 'Last name' },
+            { name: 'phoneNumber', label: 'Phone' },
+            { name: 'isActive', label: 'Active', type: 'bool' }, { name: 'emailConfirmed', label: 'Email confirmed', type: 'bool' },
+            { name: 'mustChangePassword', label: 'Must change password', type: 'bool' },
+            { name: 'roleIds', label: 'Roles', type: 'multi', options: await roleChoices(coworkee) },
+            ...(coworkee.can('Identity.Groups.View') ? [{ name: 'groupIds', label: 'Groups', type: 'lookup', lookup: groupLookup(coworkee) }] : []),
+        ],
+        values: async (user, { request }) => {
+            const detail = await request(`${identity}/users/${user.id}`);
+            return { ...detail, roleIds: detail.roles.map((role) => role.id), groupIds: detail.groups.map((group) => ({ value: group.id, label: group.name })) };
+        },
+        save: async (user, values, coworkee) => {
+            const detail = await coworkee.request(`${identity}/users/${user.id}`);
+            await coworkee.request(`${identity}/users/${user.id}`, json('PUT', {
+                firstName: values.firstName, lastName: values.lastName, userName: values.userName, phoneNumber: values.phoneNumber, address: detail.address ?? null,
+                isActive: values.isActive, emailConfirmed: values.emailConfirmed, mustChangePassword: values.mustChangePassword,
+            }));
+            await coworkee.request(`${identity}/users/${user.id}/roles`, json('PUT', { ids: values.roleIds }));
+            if (values.groupIds)
+                await coworkee.request(`${identity}/users/${user.id}/groups`, json('PUT', { ids: values.groupIds }));
+        },
+    },
+    remove: { permission: 'Identity.Users.Manage', run: (user, { request }) => request(`${identity}/users/${user.id}`, json('DELETE')), name: (user) => user.email },
+    actions: [
+        {
+            title: 'Permissions', icon: '🛡', permission: 'Identity.Permissions.Manage',
+            run: (user, coworkee) => editGrants(coworkee, 'User', user.id, user.email),
+        },
+        {
+            title: 'Set password', icon: '🔑', permission: 'Identity.Users.Manage',
+            run: async (user, coworkee) => !!await formDialog(coworkee, {
+                title: `${coworkee.t('Set password')} - ${user.email}`,
+                fields: [{ name: 'password', label: 'New password', type: 'password', required: true }, { name: 'mustChangePassword', label: 'Must change password', type: 'bool' }],
+                onSubmit: (values) => coworkee.request(`${identity}/users/${user.id}/password`, json('PUT', values)),
+            }) && false,
+        },
+        { title: 'Lock', icon: '🔒', permission: 'Identity.Users.Manage', run: (user, { request }) => request(`${identity}/users/${user.id}/lock`, json('POST', { until: null })) },
+        { title: 'Unlock', icon: '🔓', permission: 'Identity.Users.Manage', run: (user, { request }) => request(`${identity}/users/${user.id}/unlock`, json('POST')) },
+        {
+            title: 'Send password reset', icon: '✉', permission: 'Identity.Users.Manage',
+            run: async (user, coworkee) => { await coworkee.request(`${identity}/users/${user.id}/password-reset`, json('POST')); coworkee.notify(coworkee.t('Password reset mail queued for {0}.', user.email)); return false; },
+        },
+        {
+            title: 'Sign out everywhere', icon: '⏻', permission: 'Identity.Users.Manage',
+            run: async (user, coworkee) => { await coworkee.request(`${identity}/users/${user.id}/sign-out`, json('POST')); coworkee.notify(coworkee.t('The user was signed out everywhere.')); return false; },
+        },
+    ],
+    live: () => ['tenant:users'],
+});
+export const groupsApp = crudApp({
+    id: 'coworkee.admin.groups', group: 'Identity', title: 'Groups', icon: 'ratio-personal.png', accent: '#6a1b9a',
+    permissions: ['Identity.Groups.View'],
+    search: true, serverSearch: true,
+    load: async ({ request }, { page, pageSize, search }) => {
+        const result = await request(`${identity}/groups?${new URLSearchParams({ Page: String(page), PageSize: String(pageSize), Search: search })}`);
+        return { items: result.items, total: Number(result.totalCount) };
+    },
+    columns: [
+        { field: 'name', title: 'Name' }, { field: 'description', title: 'Description' },
+        { field: 'memberIds', title: 'Members', format: (group) => String(group.memberIds.length) },
+    ],
+    create: {
+        permission: 'Identity.Groups.Manage',
+        fields: [{ name: 'name', label: 'Name', required: true }, { name: 'description', label: 'Description', type: 'textarea' }],
+        save: (values, { request }) => request(`${identity}/groups`, json('POST', values)),
+    },
+    edit: {
+        permission: 'Identity.Groups.Manage',
+        fields: async (coworkee) => [
+            { name: 'name', label: 'Name', required: true }, { name: 'description', label: 'Description', type: 'textarea' },
+            { name: 'memberIds', label: 'Members', type: 'lookup', lookup: userLookup(coworkee) },
+            { name: 'roleIds', label: 'Roles', type: 'multi', options: await roleChoices(coworkee) },
+        ],
+        save: async (group, values, { request }) => {
+            await request(`${identity}/groups/${group.id}`, json('PUT', { name: values.name, description: values.description }));
+            await request(`${identity}/groups/${group.id}/members`, json('PUT', { ids: values.memberIds }));
+            await request(`${identity}/groups/${group.id}/roles`, json('PUT', { ids: values.roleIds }));
+        },
+    },
+    remove: { permission: 'Identity.Groups.Manage', run: (group, { request }) => request(`${identity}/groups/${group.id}`, json('DELETE')) },
+    actions: [{ title: 'Permissions', icon: '🛡', permission: 'Identity.Permissions.Manage', run: (group, coworkee) => editGrants(coworkee, 'Group', group.id, group.name) }],
+});
+const roleFields = [
+    { name: 'name', label: 'Name', required: true }, { name: 'description', label: 'Description', type: 'textarea' },
+    { name: 'selectableForRegistration', label: 'Selectable for registration', type: 'bool' },
+];
+export const rolesApp = crudApp({
+    id: 'coworkee.admin.roles', group: 'Identity', title: 'Roles', icon: 'fn-abcAnalysis.png', accent: '#ad1457',
+    permissions: ['Identity.Roles.View'],
+    search: true,
+    load: async ({ request }) => ({ items: await request(`${identity}/roles`) }),
+    columns: [{ field: 'name', title: 'Name' }, { field: 'description', title: 'Description' }, { field: 'isSystem', title: 'System', format: (role) => check(role.isSystem), html: true }],
+    create: { permission: 'Identity.Roles.Manage', fields: roleFields, save: (values, { request }) => request(`${identity}/roles`, json('POST', values)) },
+    edit: { permission: 'Identity.Roles.Manage', fields: roleFields, when: (role) => !role.isSystem, save: (role, values, { request }) => request(`${identity}/roles/${role.id}`, json('PUT', values)) },
+    remove: { permission: 'Identity.Roles.Manage', when: (role) => !role.isSystem, run: (role, { request }) => request(`${identity}/roles/${role.id}`, json('DELETE')) },
+    actions: [{ title: 'Permissions', icon: '🛡', permission: 'Identity.Permissions.Manage', run: (role, coworkee) => editGrants(coworkee, 'Role', role.id, role.name) }],
+});
+const clientFields = [
+    { name: 'clientId', label: 'Client id', required: true, hint: 'Letters, digits and . _ : - only' }, { name: 'displayName', label: 'Display name' },
+    { name: 'clientType', label: 'Type', type: 'select', options: ['public', 'confidential'].map((value) => ({ value, label: value })) },
+    { name: 'consentType', label: 'Consent', type: 'select', options: ['implicit', 'explicit', 'external', 'systematic'].map((value) => ({ value, label: value })) },
+    { name: 'redirectUris', label: 'Redirect addresses', type: 'list', hint: 'Full addresses like https://app.example/callback' },
+    { name: 'postLogoutRedirectUris', label: 'Addresses after sign-out', type: 'list', hint: 'Full addresses like https://app.example/callback' },
+    { name: 'grantTypes', label: 'Type', type: 'list', hint: 'Pick a suggestion or type your own' },
+    { name: 'scopes', label: 'Scopes', type: 'list', hint: 'Pick a suggestion or type your own' },
+    { name: 'clientUri', label: 'Address' }, { name: 'logoUrl', label: 'Logo address' }, { name: 'description', label: 'Description', type: 'textarea' },
+    { name: 'showInLauncher', label: 'Show in the app launcher', type: 'bool', hint: 'The app launcher of the sign-in server links here' },
+];
+const showSecret = async (coworkee, result) => {
+    if (result?.clientSecret)
+        await infoDialog(coworkee, coworkee.t('Client secret'), `<p>${esc(coworkee.t('Copy the secret now, it is not shown again:'))}</p><pre class="cw-secret">${esc(result.clientSecret)}</pre>`);
+};
+export const clientsApp = crudApp({
+    id: 'coworkee.admin.clients', group: 'Identity', title: 'Applications', icon: 'fn-userweblink.png', accent: '#00695c', width: 940,
+    permissions: ['Identity.Clients.Manage'], hostOnly: true,
+    search: true,
+    load: async ({ request }) => ({ items: await request(`${identity}/clients`) }),
+    columns: [
+        { field: 'clientId', title: 'Client id' }, { field: 'displayName', title: 'Display name' }, { field: 'clientType', title: 'Type' },
+        { field: 'managed', title: 'Service client', format: (client) => check(client.managed), html: true },
+    ],
+    create: {
+        values: { clientType: 'public', consentType: 'implicit', grantTypes: ['authorization_code', 'refresh_token'], scopes: ['openid', 'profile', 'email', 'offline_access'] },
+        fields: clientFields,
+        save: async (values, coworkee) => showSecret(coworkee, await coworkee.request(`${identity}/clients`, json('POST', values))),
+    },
+    edit: {
+        fields: clientFields, when: (client) => !client.managed,
+        save: async (client, values, coworkee) => showSecret(coworkee, await coworkee.request(`${identity}/clients/${client.id}`, json('PUT', { ...client, ...values }))),
+    },
+    remove: { when: (client) => !client.managed, run: (client, { request }) => request(`${identity}/clients/${client.id}`, json('DELETE')), name: (client) => client.clientId },
+    actions: [
+        {
+            title: 'New secret', icon: '&#x1f511;', visible: (client) => client.clientType === 'confidential' && !client.managed,
+            run: async (client, coworkee) => { await showSecret(coworkee, await coworkee.request(`${identity}/clients/${client.id}/secret`, json('POST'))); return false; },
+        },
+        {
+            title: 'Duplicate', icon: '&#x2398;', visible: (client) => !client.managed,
+            run: async (client, coworkee) => !!await formDialog(coworkee, {
+                title: coworkee.t('Duplicate'), fields: clientFields, values: { ...client, clientId: `${client.clientId}-copy` },
+                onSubmit: async (values) => showSecret(coworkee, await coworkee.request(`${identity}/clients`, json('POST', values))),
+            }),
+        },
+    ],
+});
+const scopeFields = [
+    { name: 'name', label: 'Name', required: true }, { name: 'displayName', label: 'Display name' },
+    { name: 'description', label: 'Description', type: 'textarea' }, { name: 'resources', label: 'Resources', type: 'list', hint: 'Audiences of the access token, e.g. https://api.example' },
+];
+export const scopesApp = crudApp({
+    id: 'coworkee.admin.scopes', group: 'Identity', title: 'Scopes', icon: 'icon-percent.png', accent: '#4e342e',
+    permissions: ['Identity.Clients.Manage'], hostOnly: true,
+    search: true,
+    load: async ({ request }) => ({ items: await request(`${identity}/scopes`) }),
+    columns: [
+        { field: 'name', title: 'Name' }, { field: 'displayName', title: 'Display name' }, { field: 'resources', title: 'Resources', format: (scope) => scope.resources.join(', ') },
+        { field: 'builtIn', title: 'built-in', format: (scope) => check(scope.builtIn), html: true },
+    ],
+    create: { fields: scopeFields, save: (values, { request }) => request(`${identity}/scopes`, json('POST', values)) },
+    edit: { fields: scopeFields, when: (scope) => !scope.builtIn, save: (scope, values, { request }) => request(`${identity}/scopes/${scope.id}`, json('PUT', values)) },
+    remove: { when: (scope) => !scope.builtIn, run: (scope, { request }) => request(`${identity}/scopes/${scope.id}`, json('DELETE')) },
+});
+const inDays = (days) => new Date(Date.now() + days * 86400000).toISOString();
+export const apiKeysApp = crudApp({
+    id: 'coworkee.admin.api-keys', group: 'Identity', title: 'API keys', icon: 'login-password.png', accent: '#37474f', width: 900,
+    permissions: ['ApiKeys.Manage'],
+    load: async ({ request }) => ({ items: await request(`${identity}/api-keys`) }),
+    columns: [
+        { field: 'name', title: 'Name' }, { field: 'prefix', title: 'Key' }, { field: 'scopes', title: 'Scopes', format: (key) => key.scopes.join(', ') },
+        { field: 'expiresAt', title: 'Expires' }, { field: 'lastUsedAt', title: 'Last used' },
+        { field: 'revokedAt', title: 'Revoked', format: (key, { culture }) => display(key.revokedAt, culture) },
+    ],
+    create: {
+        values: { expiresAt: inDays(90) },
+        fields: async ({ request, t }) => {
+            const groups = await request(`${identity}/api-keys/scopes`);
+            return [
+                { name: 'name', label: 'Name', required: true }, { name: 'description', label: 'Description', type: 'textarea' },
+                { name: 'expiresAt', label: 'Expires', type: 'date', required: true },
+                { name: 'scopes', label: 'Scopes', type: 'multi', options: groups.flatMap((group) => group.permissions.map((p) => ({ value: p.name, label: `${t(group.displayName)}: ${t(p.displayName)}` }))) },
+            ];
+        },
+        save: async (values, coworkee) => {
+            const created = await coworkee.request(`${identity}/api-keys`, json('POST', values));
+            void infoDialog(coworkee, coworkee.t('API key'), `<p>${esc(coworkee.t('Copy the key now: it is shown only this once.'))}</p><pre class="cw-secret">${esc(created.secret)}</pre>`);
+        },
+    },
+    actions: [{ title: 'Revoke', icon: '&#x26d4;', visible: (key) => !key.revokedAt, run: (key, { request }) => request(`${identity}/api-keys/${key.id}/revoke`, json('POST')) }],
+});
+export const identityApps = [usersApp, groupsApp, rolesApp, clientsApp, scopesApp, apiKeysApp];

package/dist/apps/admin/index.d.ts

@@ -0,0 +1,9 @@
+import type { AppFactory, Coworkee, CoworkeeApp } from '../../coworkee.ts';
+export declare const administrationAppId = "coworkee.administration";
+/** Every administration app the user may open, grouped like the administration menu of the web app. */
+export declare const administrationApp: (coworkee: Coworkee) => CoworkeeApp;
+/** The administration: users, groups, roles, applications, scopes, API keys, themes, languages, translations, mail, backups, audit and more. */
+export declare const adminApps: AppFactory[];
+export * from './identity.ts';
+export * from './mail.ts';
+export * from './system.ts';

package/dist/apps/admin/index.js

@@ -0,0 +1,48 @@
+import { esc } from "../../dom.js";
+import { aiSettingsApp } from "../assistant.js";
+import { identityApps } from "./identity.js";
+import { mailApps } from "./mail.js";
+import { systemApps } from "./system.js";
+export const administrationAppId = 'coworkee.administration';
+const sections = ['Identity', 'System', 'Communication', 'Localization', 'Monitoring'];
+/** No user holds it: the administration app stays out of sight while none of its apps is allowed. */
+const nobody = 'Coworkee.Administration.None';
+const allowed = (coworkee) => coworkee.apps.filter((app) => app.group && !app.hidden && (app.requiredPermissions ?? []).every(coworkee.can));
+/** Every administration app the user may open, grouped like the administration menu of the web app. */
+export const administrationApp = (coworkee) => {
+    const definition = (visible) => ({
+        id: administrationAppId, title: coworkee.t('Administration'), icon: 'startmenu-settings.png', accent: '#35496b', width: 760, height: 560, singleInstance: true,
+        requiredPermissions: visible ? [] : [nobody],
+        render: ({ host }) => {
+            const { t } = coworkee;
+            const apps = allowed(coworkee);
+            host.classList.add('cw-host');
+            host.innerHTML = `<div class="cw-app cw-admin">${[...sections, ...new Set(apps.map((app) => app.group))].filter((section, index, all) => all.indexOf(section) === index)
+                .map((section) => [section, apps.filter((app) => app.group === section)]).filter(([, items]) => items.length > 0)
+                .map(([section, items]) => `<section><h3>${esc(t(section))}</h3><div class="cw-tiles">${items.map((app) => `<button data-open="${esc(app.id)}" style="--cw-tile:${esc(app.accent ?? '#35496b')}"><img src="${esc(/[/:]/.test(app.icon) ? app.icon : `/icons/${app.icon}`)}" alt=""/><span>${esc(app.title)}</span></button>`).join('')}</div></section>`).join('')
+                || `<p class="cw-muted">${esc(t('Nothing found.'))}</p>`}</div>`;
+            host.addEventListener('click', (event) => {
+                const id = event.target.closest('[data-open]')?.dataset.open;
+                if (id)
+                    coworkee.airWorks.openApp(id);
+            });
+        },
+    });
+    // hidden until the access of the signed-in user is known; every change of the access decides again
+    let visible = false;
+    const update = () => {
+        const now = allowed(coworkee).length > 0;
+        if (now === visible)
+            return;
+        visible = now;
+        coworkee.airWorks.unregisterApp(administrationAppId);
+        coworkee.airWorks.registerApp(definition(now));
+    };
+    coworkee.airWorks.on('access-changed', update);
+    return definition(false);
+};
+/** The administration: users, groups, roles, applications, scopes, API keys, themes, languages, translations, mail, backups, audit and more. */
+export const adminApps = [administrationApp, ...identityApps, ...systemApps, ...mailApps, aiSettingsApp];
+export * from "./identity.js";
+export * from "./mail.js";
+export * from "./system.js";

package/dist/apps/admin/mail.d.ts

@@ -0,0 +1,20 @@
+import type { Schemas } from '@coworkee/client';
+import type { Coworkee, CoworkeeApp } from '../../coworkee.ts';
+import { type Values } from '../../form.ts';
+type Source = Schemas['RecipientSourceDto'];
+export declare const mailTemplateAppId = "coworkee.admin.mail-template";
+export declare const mailLogAppId = "coworkee.admin.mail-log";
+/** The recipient source the API takes from the form values: only the fields of the chosen kind. */
+export declare const sourceOf: (values: Values) => Source;
+/** How many users a source reaches, without those who unsubscribed, and the first of them. */
+export declare function previewRecipients(coworkee: Coworkee, source: Source): Promise<boolean>;
+export declare const mailTemplatesApp: (coworkee: Coworkee) => CoworkeeApp;
+/** Subject and body of a template in one language with a live preview, a test mail to oneself and the way back to the default. */
+export declare const mailTemplateApp: (coworkee: Coworkee) => CoworkeeApp;
+export declare const mailCampaignsApp: (coworkee: Coworkee) => CoworkeeApp;
+export declare const recipientListsApp: (coworkee: Coworkee) => CoworkeeApp;
+/** The mails the app sent or queued; opened from a campaign it shows that campaign's mails. */
+export declare const mailLogApp: (coworkee: Coworkee) => CoworkeeApp;
+export declare const mailSettingsApp: (coworkee: Coworkee) => CoworkeeApp;
+export declare const mailApps: ((coworkee: Coworkee) => CoworkeeApp)[];
+export {};