@appsemble/cli 0.20.44 → 0.21.0

package/README.md

@@ -1,20 +1,24 @@
-# ![](https://gitlab.com/appsemble/appsemble/-/raw/0.20.44/config/assets/logo.svg) Appsemble CLI
+# ![](https://gitlab.com/appsemble/appsemble/-/raw/0.21.0/config/assets/logo.svg) Appsemble CLI
 
 > Manage apps and blocks from the command line.
 
 [![npm](https://img.shields.io/npm/v/@appsemble/cli)](https://www.npmjs.com/package/@appsemble/cli)
-[![GitLab CI](https://gitlab.com/appsemble/appsemble/badges/0.20.44/pipeline.svg)](https://gitlab.com/appsemble/appsemble/-/releases/0.20.44)
+[![GitLab CI](https://gitlab.com/appsemble/appsemble/badges/0.21.0/pipeline.svg)](https://gitlab.com/appsemble/appsemble/-/releases/0.21.0)
 [![Prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://prettier.io)
 
 ## Table of Contents
 
 - [Installation](#installation)
 - [Usage](#usage)
+  - [Development server](#development-server)
   - [Authentication](#authentication)
   - [Organizations](#organizations)
   - [Apps](#apps)
   - [Blocks](#blocks)
+  - [Teams](#teams)
   - [Assets](#assets)
+  - [Resources](#resources)
+  - [Cronjobs](#cronjobs)
 - [License](#license)
 
 ## Installation
@@ -33,6 +37,76 @@ appsemble --help
 
 Every subcommand also supports the `--help` flag.
 
+### Development server
+
+The development server can create an app from a specified folder containing an `app-definition.yml`
+file. It will check what blocks are needed for the app and will try to load them from the local
+workspaces, listed in the `package.json` file in the root of the project, if they are present. This
+way, all default Appsemble blocks shipped with Appsemble are loaded automatically.
+
+Once the development server is started, making a change to a block’s code or styles will reflect in
+the browser immediately after refreshing the page, without the need of increasing the block’s
+version. Running docker database containers, creating a user account and creating an organization
+are not needed.
+
+The Appsemble CLI can be used to start the development server. For example, the following command
+serves `my-app`:
+
+```sh
+appsemble serve <path-to-app-directory>
+```
+
+This will serve the app on `http://localhost:9090`.
+
+A different port can be specified with the `--port` parameter.
+
+The following option allows you to view the app with a specified role:
+
+```sh
+appsemble serve <path-to-app-directory> --user-role test
+```
+
+The following option allows you to view the app as a Manager of a team:
+
+```sh
+appsemble serve <path-to-app-directory> --team-role Manager
+```
+
+App data is stored within a `db.json` file in your machine’s cache directory. Each app has their own
+directory `<my-app>`.
+
+```sh
+MacOS - /Users/<my-name>/Library/Caches/appsemble/<my-app>
+Linux - /home/<my-name>/.cache/appsemble/<my-app>
+Windows - C:\Users\<my-name>\AppData\Local\appsemble\Cache\<my-app>
+```
+
+App assets will be served from the local file system.
+
+The development server will automatically fetch all blocks that are needed for the served app but
+are missing from the local workspaces. These are typically third-party or proprietary blocks. The
+development server will use `https://appsemble.app` as the default remote server to fetch blocks
+from. The following option allows you to specify a different remote server:
+
+```sh
+appsemble serve <path-to-app-directory> --remote <remote>
+```
+
+The development server will use the corresponding block directory in your machine’s cache directory
+to store and read block manifests and assets.
+
+```sh
+MacOS - /Users/<my-name>/Library/Caches/appsemble/blocks/<organisation>/<block-name>/<block-version>
+Linux - /home/<my-name>/.cache/appsemble/blocks/<organisation>/<block-name>/<block-version>
+Windows - C:\Users\<my-name>\AppData\Local\appsemble\Cache\blocks\<organisation>\<block-name>\<block-version>
+```
+
+You can overwrite the existing block cache with the following option:
+
+```sh
+appsemble serve <path-to-app-directory> --remote <remote> --overwrite-block-cache
+```
+
 ### Authentication
 
 The Appsemble CLI uses OAuth2 client credentials to authenticate to the Appsemble server.
@@ -69,6 +143,12 @@ The Appsemble CLI can be used to create and update apps. For example, to create
 appsemble app create apps/my-app
 ```
 
+Similarly, to update an app using an app directory, run the following command:
+
+```sh
+appsemble app update --id <app-id> <path/to/updated app>.
+```
+
 For a more in depth explanation of how to build apps, use our
 [app building guide](https://appsemble.app/docs/guide).
 
@@ -94,6 +174,15 @@ npm install webpack@webpack-4 @appsemble/webpack-config
 For a more in-depth explanation of how to build apps, use our
 [block development guide](https://appsemble.app/docs/development/developing-blocks).
 
+### Teams
+
+The Appsemble CLI can be used to manage teams for apps. For example, the following command creates a
+new team named `My Team`:
+
+```sh
+appsemble team create 'My Team' --app-id 1 --context development
+```
+
 ### Assets
 
 The Appsemble CLI can be used to upload assets from disk. For example, the following command creates
@@ -103,7 +192,60 @@ an asset named `example-asset`:
 appsemble asset create --app-id 1 path/to/example-asset.png
 ```
 
+### Resources
+
+The Appsemble CLI can be used to create a resource from a JSON file or directory:
+
+```json
+[
+  {
+    "title": "My Resource",
+    "description": "This record is an example."
+  }
+]
+```
+
+```sh
+appsemble resource create --app-id 1 --context development --app path/to/my-app my-resource path/to/resources/my-resource.json
+```
+
+```sh
+appsemble resource create --app-id 1 --context development --app path/to/my-app my-resource path/to/resources/*
+```
+
+And resources can also be updated when they contain an id in the JSON file.
+
+```json
+[
+  {
+    "id": 1,
+    "title": "My Updated Resource",
+    "description": "This will be the updated content of the first my-resource record."
+  }
+]
+```
+
+```sh
+appsemble resource update --app-id 1 --context development --app path/to/my-app my-resource path/to/resources/*
+```
+
+### Cronjobs
+
+The Appsemble CLI can be used to run app cronjobs. The following command runs all cronjobs that were
+scheduled to run in the past 5 minutes:
+
+```sh
+appsemble run-cronjobs
+```
+
+How often jobs are run (more accurately how far back the job can be scheduled for it to run) the
+time interval (in minutes) can also be set with:
+
+```sh
+appsemble run-cronjobs --interval 30
+```
+
 ## License
 
-[LGPL-3.0-only](https://gitlab.com/appsemble/appsemble/-/blob/0.20.44/LICENSE.md) ©
+[LGPL-3.0-only](https://gitlab.com/appsemble/appsemble/-/blob/0.21.0/LICENSE.md) ©
 [Appsemble](https://appsemble.com)

package/commands/app/create.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="node" />
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { type ReadStream } from 'node:fs';
 import { type AppVisibility } from '@appsemble/types';
 import { type Argv } from 'yargs';

package/commands/app/update.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="node" />
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { type ReadStream } from 'node:fs';
 import { type AppVisibility } from '@appsemble/types';
 import { type Argv } from 'yargs';

package/commands/organization/create.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 import { type ReadStream } from 'node:fs';
 import { type Argv } from 'yargs';
 import { type BaseArguments } from '../../types.js';

package/commands/organization/update.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 import { type ReadStream } from 'node:fs';
 import { type Argv } from 'yargs';
 import { type BaseArguments } from '../../types.js';

package/commands/serve.d.ts

@@ -0,0 +1,15 @@
+import { type Argv } from 'yargs';
+import { type BaseArguments } from '../types.js';
+interface ServeArguments extends BaseArguments {
+    path: string;
+    port: number;
+    'api-port': number;
+    'user-role': string;
+    'team-role': string;
+    'overwrite-block-cache': boolean;
+}
+export declare const command = "serve path";
+export declare const description = "Serve an app with a local development server.";
+export declare function builder(yargs: Argv): Argv<any>;
+export declare function handler(argv: ServeArguments): Promise<void>;
+export {};

package/commands/serve.js

@@ -0,0 +1,265 @@
+import { createWriteStream, existsSync } from 'node:fs';
+import { mkdir, readFile } from 'node:fs/promises';
+import http from 'node:http';
+import { basename, extname, join, parse } from 'node:path';
+import { Readable } from 'node:stream';
+import { AppsembleError, logger, opendirSafe, readData, writeData, } from '@appsemble/node-utils';
+import { asciiLogo, getAppBlocks, normalize, parseBlockName, } from '@appsemble/utils';
+import axios from 'axios';
+import csvToJson from 'csvtojson';
+import FormData from 'form-data';
+import globalCacheDir from 'global-cache-dir';
+import { traverseAppDirectory } from '../lib/app.js';
+import { buildBlock, getBlockConfig, makePayload } from '../lib/block.js';
+import { createApiServer, createStaticServer } from '../lib/createServers.js';
+import { loadWebpackConfig } from '../lib/loadWebpackConfig.js';
+import { setAppName } from '../server/db/methods.js';
+import { Resource } from '../server/models/Resource.js';
+export const command = 'serve path';
+export const description = 'Serve an app with a local development server.';
+export function builder(yargs) {
+    return yargs
+        .positional('path', {
+        describe: 'The path to the app to publish.',
+    })
+        .option('port', {
+        desc: 'The static HTTP server port to use. This is the port where the app is accessible.',
+        type: 'number',
+        default: 9090,
+    })
+        .option('api-port', {
+        desc: 'The Appsemble development HTTP server port to use. This is the port where the Appsemble development API endpoints are available.',
+        type: 'number',
+        default: 9191,
+    })
+        .option('user-role', {
+        desc: 'The role to set to the mocked authenticated user.',
+        type: 'string',
+    })
+        .option('team-role', {
+        desc: 'The role to set to the mocked authenticated user in the team.',
+        type: 'string',
+        default: 'member',
+    })
+        .option('remote', {
+        desc: 'The address to fetch remote blocks from.',
+        type: 'string',
+    })
+        .option('overwrite-block-cache', {
+        desc: 'Whether to overwrite remote blocks cache if it exists.',
+        type: 'boolean',
+        default: false,
+    });
+}
+export async function handler(argv) {
+    const appPath = join(process.cwd(), argv.path);
+    const [, , , appsembleApp] = await traverseAppDirectory(appPath, 'development', new FormData());
+    const appRoles = appsembleApp.definition.roles;
+    const passedUserRole = argv['user-role'];
+    if (passedUserRole && !(appRoles === null || appRoles === void 0 ? void 0 : appRoles.includes(passedUserRole))) {
+        throw appRoles
+            ? new AppsembleError(`The specified role "${passedUserRole}" is not supported by this app. Supported roles are [${appRoles}]`)
+            : new AppsembleError('This app does not support roles');
+    }
+    const appSecurity = appsembleApp.definition.security;
+    const appMembers = [
+        {
+            id: '1',
+            name: 'dev',
+            primaryEmail: 'dev@example.com',
+            role: passedUserRole || (appSecurity === null || appSecurity === void 0 ? void 0 : appSecurity.default.role),
+        },
+    ];
+    const allowedTeamRoles = ['manager', 'member'];
+    const passedTeamRole = argv['team-role'];
+    if (passedTeamRole && !allowedTeamRoles.includes(passedTeamRole)) {
+        throw new AppsembleError(`The specified team role ${passedTeamRole} is not supported. Allowed roles are [member,manager]`);
+    }
+    const appTeams = [
+        {
+            id: 1,
+            name: 'team',
+            size: 1,
+            role: passedTeamRole,
+            annotations: {},
+        },
+    ];
+    const appUserInfo = {
+        email: 'dev@example.com',
+        email_verified: true,
+        name: 'dev',
+        sub: '1',
+    };
+    const appName = normalize(appsembleApp.definition.name);
+    const appId = 1;
+    setAppName(appName);
+    const identifiableBlocks = getAppBlocks(appsembleApp.definition);
+    const localIdentifiableBlocks = [];
+    const remoteIdentifiableBlocks = [];
+    for (const identifiableBlock of identifiableBlocks) {
+        const [, blockName] = parseBlockName(identifiableBlock.type);
+        if (existsSync(join(process.cwd(), 'blocks', blockName))) {
+            localIdentifiableBlocks.push(identifiableBlock);
+        }
+        else {
+            remoteIdentifiableBlocks.push(identifiableBlock);
+        }
+    }
+    const localBlocksConfigs = await Promise.all(localIdentifiableBlocks.map(async (identifiableBlock) => {
+        const [organization, blockName] = parseBlockName(identifiableBlock.type);
+        const blockConfig = await getBlockConfig(join(process.cwd(), 'blocks', blockName));
+        return {
+            ...blockConfig,
+            OrganizationId: organization,
+        };
+    }));
+    const localBlocksPromises = localBlocksConfigs.map(async (blockConfig) => {
+        await buildBlock(blockConfig);
+        const [, blockManifest] = await makePayload(blockConfig);
+        blockManifest.version = localIdentifiableBlocks.find((identifiableBlock) => identifiableBlock.type === blockManifest.name).version;
+        return blockManifest;
+    });
+    const cacheDir = await globalCacheDir('appsemble');
+    const remoteBlocksPromises = remoteIdentifiableBlocks.map(async (identifiableBlock) => {
+        const [organization, blockName] = parseBlockName(identifiableBlock.type);
+        const blockCacheDir = join(cacheDir, 'blocks', organization, blockName, identifiableBlock.version);
+        const cachedBlockManifest = join(blockCacheDir, 'manifest.json');
+        const cacheExists = existsSync(cachedBlockManifest);
+        if (!cacheExists || (cacheExists && argv['overwrite-block-cache'])) {
+            const blockUrl = `/api/blocks/@${organization}/${blockName}/versions/${identifiableBlock.version}`;
+            const { data: blockManifest } = await axios.get(String(new URL(blockUrl, argv.remote)));
+            await writeData(cachedBlockManifest, blockManifest);
+            const assetsDir = join(blockCacheDir, 'assets');
+            if (!existsSync(assetsDir)) {
+                await mkdir(assetsDir);
+            }
+            const blockFilesPromises = blockManifest.files.map(async (filename) => {
+                const writer = createWriteStream(join(assetsDir, filename));
+                const { data: content } = await axios.get(String(new URL(`${blockUrl}/asset?filename=${filename}`, argv.remote)), {
+                    responseType: 'stream',
+                });
+                content.pipe(writer);
+            });
+            await Promise.all(blockFilesPromises);
+            return blockManifest;
+        }
+        const [blockManifest] = await readData(cachedBlockManifest);
+        return blockManifest;
+    });
+    const localBlocks = await Promise.all(localBlocksPromises);
+    const remoteBlocks = await Promise.all(remoteBlocksPromises);
+    const appBlocks = [...localBlocks, ...remoteBlocks];
+    const webpackConfigs = await Promise.all(localBlocksConfigs.map((blockConfig) => loadWebpackConfig(blockConfig, 'development', join(blockConfig.dir, blockConfig.output))));
+    // Get app messages
+    const appMessages = [];
+    await opendirSafe(join(appPath, 'i18n'), async (path) => {
+        logger.verbose(`Processing ${path} ⚙️`);
+        const { name: language } = parse(path);
+        if (appMessages.some((entry) => entry.language === language)) {
+            throw new AppsembleError(`Found duplicate language “${language}”. Make sure each language only exists once in the directory.`);
+        }
+        const [messages] = await readData(path);
+        appMessages.push({ language, messages });
+    }, { allowMissing: true });
+    // Get app assets
+    const appAssets = [];
+    await opendirSafe(join(appPath, 'assets'), (path) => {
+        logger.verbose(`Processing ${path} ⚙️`);
+        const extension = extname(path);
+        const name = basename(path, extension);
+        appAssets.push({
+            id: name,
+            mime: extension,
+            filename: path,
+            name,
+        });
+    }, { allowMissing: true });
+    // Get app resources
+    await opendirSafe(join(appPath, 'resources'), async (path, stat) => {
+        logger.verbose(`Processing ${path} ⚙️`);
+        let resources;
+        if (path.endsWith('.csv')) {
+            const data = await readFile(path);
+            const stream = Readable.from(data);
+            resources = await csvToJson({}).fromStream(stream);
+        }
+        else {
+            const [resource] = await readData(path);
+            if (typeof resource !== 'object') {
+                throw new AppsembleError(`File at ${path} does not contain an object or array of objects`);
+            }
+            resources = [].concat(resource);
+        }
+        logger.info(`Creating resource(s) from ${path}`);
+        const { name } = parse(stat.name);
+        await Resource.bulkCreate(resources, name, true);
+    }, { allowMissing: true });
+    const stubbedApp = {
+        ...appsembleApp,
+        id: appId,
+        path: appPath,
+        coreStyle: appsembleApp.coreStyle || '',
+        sharedStyle: appsembleApp.sharedStyle || '',
+        $updated: new Date().toISOString(),
+    };
+    const appsembleApiServer = createApiServer({
+        argv,
+        context: {
+            appHost: `http://localhost:${argv.port}`,
+            appsembleApp: stubbedApp,
+            appBlocks,
+            appMessages,
+            ...(appSecurity
+                ? {
+                    appMembers,
+                    appUserInfo,
+                    appTeams,
+                }
+                : {}),
+            appAssets,
+            blockConfigs: localBlocksConfigs,
+        },
+    });
+    appsembleApiServer.on('error', (err) => {
+        if (err.expose) {
+            return;
+        }
+        logger.error(err);
+    });
+    const api = http.createServer(appsembleApiServer.callback());
+    const staticServer = await createStaticServer({
+        argv,
+        context: {
+            apiUrl: `http://localhost:${argv['api-port']}`,
+            appHost: `http://localhost:${argv.port}`,
+            appsembleApp: stubbedApp,
+            appBlocks,
+            appMessages,
+            ...(appSecurity
+                ? {
+                    appMembers,
+                    appUserInfo,
+                    appTeams,
+                }
+                : {}),
+            appAssets,
+            blockConfigs: localBlocksConfigs,
+        },
+        webpackConfigs,
+    });
+    staticServer.on('error', (err) => {
+        if (err.expose) {
+            return;
+        }
+        logger.error(err);
+    });
+    const app = http.createServer(staticServer.callback());
+    api.listen(argv['api-port'], '::', () => {
+        logger.info(asciiLogo);
+        logger.info(`The api can be found on\n> http://localhost:${argv['api-port']}`);
+    });
+    app.listen(argv.port, '::', () => {
+        logger.info(`\nThe app can be found on\n> http://localhost:${argv.port}`);
+    });
+}
+//# sourceMappingURL=serve.js.map

package/index.js

@@ -14,6 +14,7 @@ import * as migrate from './commands/migrate.js';
 import * as organization from './commands/organization/index.js';
 import * as resource from './commands/resource/index.js';
 import * as runCronJobs from './commands/runCronJobs.js';
+import * as serve from './commands/serve.js';
 import * as start from './commands/start.js';
 import * as team from './commands/team/index.js';
 import { CREDENTIALS_ENV_VAR } from './lib/authentication.js';
@@ -56,6 +57,7 @@ let parser = yargs(process.argv.slice(2))
     .command(resource)
     .command(runCronJobs)
     .command(start)
+    .command(serve)
     .command(team)
     .demandCommand(1)
     // .strict() isn’t used because of https://github.com/yargs/yargs/issues/2058

package/lib/app.d.ts

@@ -1,7 +1,7 @@
-/// <reference types="node" />
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { type ReadStream } from 'node:fs';
-import { type AppVisibility } from '@appsemble/types';
+import { type App, type AppVisibility } from '@appsemble/types';
 import FormData from 'form-data';
 import { type AppsembleContext, type AppsembleRC } from '../types.js';
 interface CreateAppParams {
@@ -137,7 +137,7 @@ interface UpdateAppParams {
  * @param formData The FormData object to append the results into..
  * @returns The context from `.appsemblerc.yaml` if a match was found.
  */
-export declare function traverseAppDirectory(path: string, context: string, formData: FormData): Promise<[AppsembleContext, AppsembleRC, string]>;
+export declare function traverseAppDirectory(path: string, context: string, formData: FormData): Promise<[AppsembleContext, AppsembleRC, string, App]>;
 /**
  * Upload messages for an app.
  *

package/lib/app.js

@@ -1,6 +1,6 @@
 import { createReadStream, existsSync } from 'node:fs';
 import { mkdir, readdir, readFile, stat } from 'node:fs/promises';
-import { join, parse, relative, resolve } from 'node:path';
+import { basename, join, parse, relative, resolve } from 'node:path';
 import { inspect } from 'node:util';
 import { AppsembleError, logger, opendirSafe, readData, writeData } from '@appsemble/node-utils';
 import { extractAppMessages, has, normalizeBlockName } from '@appsemble/utils';
@@ -26,6 +26,9 @@ export async function traverseAppDirectory(path, context, formData) {
     let iconPath;
     let maskableIconPath;
     let yaml;
+    const gatheredData = {
+        screenshotUrls: [],
+    };
     logger.info(`Traversing directory for App files in ${path} 🕵`);
     await opendirSafe(path, async (filepath, filestat) => {
         switch (filestat.name.toLowerCase()) {
@@ -34,6 +37,7 @@ export async function traverseAppDirectory(path, context, formData) {
                 [rc] = await readData(filepath);
                 if ('iconBackground' in rc) {
                     formData.append('iconBackground', rc.iconBackground);
+                    gatheredData.iconBackground = rc.iconBackground;
                 }
                 if (context && has(rc === null || rc === void 0 ? void 0 : rc.context, context)) {
                     discoveredContext = rc.context[context];
@@ -45,14 +49,16 @@ export async function traverseAppDirectory(path, context, formData) {
                 if (yaml !== undefined) {
                     throw new AppsembleError('Found duplicate app definition');
                 }
-                const [, data] = await readData(filepath);
-                yaml = data;
-                formData.append('yaml', data);
+                const [data, dataString] = await readData(filepath);
+                yaml = dataString;
+                formData.append('yaml', dataString);
+                gatheredData.definition = data;
                 return;
             }
             case 'icon.png':
             case 'icon.svg':
                 iconPath = filepath;
+                gatheredData.iconUrl = filepath;
                 return;
             case 'maskable-icon.png':
                 maskableIconPath = filepath;
@@ -60,6 +66,7 @@ export async function traverseAppDirectory(path, context, formData) {
             case 'readme.md':
                 logger.info(`Including longDescription from ${filepath}`);
                 formData.append('longDescription', await readFile(filepath, 'utf8'));
+                gatheredData.longDescription = await readFile(filepath, 'utf8');
                 return;
             case 'screenshots':
                 return opendirSafe(filepath, (screenshotPath, screenshotStat) => {
@@ -68,6 +75,7 @@ export async function traverseAppDirectory(path, context, formData) {
                         throw new AppsembleError(`Expected ${screenshotPath} to be an image file`);
                     }
                     formData.append('screenshots', createReadStream(screenshotPath));
+                    gatheredData.screenshotUrls.push(basename(screenshotPath));
                 }, { allowMissing: true });
             case 'theme':
                 return opendirSafe(filepath, async (themeDir, themeStat) => {
@@ -80,6 +88,7 @@ export async function traverseAppDirectory(path, context, formData) {
                     }
                     const css = await processCss(join(themeDir, 'index.css'));
                     formData.append(`${name}Style`, css);
+                    gatheredData[`${name}Style`] = await processCss(join(themeDir, 'index.css'));
                 });
             default:
                 logger.warn(`Found unused file ${filepath}`);
@@ -95,7 +104,7 @@ export async function traverseAppDirectory(path, context, formData) {
     discoveredContext.maskableIcon = discoveredContext.maskableIcon
         ? resolve(path, discoveredContext.maskableIcon)
         : maskableIconPath;
-    return [discoveredContext, rc, yaml];
+    return [discoveredContext, rc, yaml, gatheredData];
 }
 /**
  * Upload messages for an app.

package/lib/block.d.ts

@@ -1,4 +1,4 @@
-import { type BlockConfig } from '@appsemble/types';
+import { type BlockConfig, type BlockManifest } from '@appsemble/types';
 import FormData from 'form-data';
 import { type Stats } from 'webpack';
 /**
@@ -30,7 +30,7 @@ export declare function discoverBlocks(root: string): Promise<BlockConfig[]>;
  * @param config The block configuration
  * @returns The payload that should be sent to the version endpoint.
  */
-export declare function makePayload(config: BlockConfig): Promise<FormData>;
+export declare function makePayload(config: BlockConfig): Promise<[FormData, BlockManifest]>;
 /**
  * Publish a new block version.
  *