@directus/api 32.1.1 → 32.2.0

package/dist/{mcp → ai/tools}/types.d.ts

@@ -1,4 +1,4 @@
-import type { Accountability, Query, SchemaOverview } from '@directus/types';
+import type { Accountability, SchemaOverview } from '@directus/types';
 import type { ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';
 import type { ZodType } from 'zod';
 export type ToolResultBase = {
@@ -18,7 +18,6 @@ export type ToolResult = TextToolResult | AssetToolResult;
 export type ToolHandler<T> = {
     (options: {
         args: T;
-        sanitizedQuery: Query;
         schema: SchemaOverview;
         accountability: Accountability | undefined;
     }): Promise<ToolResult | undefined>;
@@ -39,18 +38,3 @@ export interface ToolConfig<T> {
     annotations?: ToolAnnotations;
     handler: ToolHandler<T>;
 }
-export interface Prompt {
-    name: string;
-    system_prompt?: string | null;
-    description?: string;
-    messages: {
-        role: 'user' | 'assistant';
-        text: string;
-    }[];
-}
-export interface MCPOptions {
-    promptsCollection?: string;
-    allowDeletes?: boolean;
-    systemPromptEnabled?: boolean;
-    systemPrompt?: string | null;
-}

package/dist/ai/tools/utils.d.ts

@@ -0,0 +1,9 @@
+import type { Accountability, SchemaOverview } from '@directus/types';
+/**
+ * Build a sanitized query object from a tool's args payload.
+ * - Ensures fields defaults to '*' when not provided
+ * - Returns an empty object when no args.query is present
+ */
+export declare function buildSanitizedQueryFromArgs<T extends {
+    query?: Record<string, any> | undefined;
+}>(args: T, schema: SchemaOverview, accountability?: Accountability | null): Promise<Record<string, any>>;

package/dist/ai/tools/utils.js

@@ -0,0 +1,17 @@
+import { sanitizeQuery } from '../../utils/sanitize-query.js';
+/**
+ * Build a sanitized query object from a tool's args payload.
+ * - Ensures fields defaults to '*' when not provided
+ * - Returns an empty object when no args.query is present
+ */
+export async function buildSanitizedQueryFromArgs(args, schema, accountability) {
+    let sanitizedQuery = {};
+    if (args?.query) {
+        const q = args.query;
+        sanitizedQuery = await sanitizeQuery({
+            fields: q['fields'] ?? '*',
+            ...q,
+        }, schema, accountability ?? undefined);
+    }
+    return sanitizedQuery;
+}

package/dist/app.js

@@ -68,6 +68,7 @@ import projectSchedule from './schedules/project.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { Url } from './utils/url.js';
 import { validateStorage } from './utils/validate-storage.js';
+import { aiChatRouter } from './ai/chat/router.js';
 const require = createRequire(import.meta.url);
 export default async function createApp() {
     const env = useEnv();
@@ -84,6 +85,9 @@ export default async function createApp() {
     if (!env['SECRET']) {
         logger.warn(`"SECRET" env variable is missing. Using a random value instead. Tokens will not persist between restarts. This is not appropriate for production usage.`);
     }
+    if (typeof env['SECRET'] === 'string' && Buffer.byteLength(env['SECRET']) < 32) {
+        logger.warn('"SECRET" env variable is shorter than 32 bytes which is insecure. This is not appropriate for production usage.');
+    }
     if (!new Url(env['PUBLIC_URL']).isAbsolute()) {
         logger.warn('"PUBLIC_URL" should be a full URL');
     }
@@ -231,6 +235,7 @@ export default async function createApp() {
     if (toBoolean(env['MCP_ENABLED']) === true) {
         app.use('/mcp', mcpRouter);
     }
+    app.use('/ai/chat', aiChatRouter);
     if (env['METRICS_ENABLED'] === true) {
         app.use('/metrics', metricsRouter);
     }

package/dist/auth/drivers/saml.js

@@ -12,9 +12,9 @@ import { respond } from '../../middleware/respond.js';
 import { AuthenticationService } from '../../services/authentication.js';
 import asyncHandler from '../../utils/async-handler.js';
 import { getConfigFromEnv } from '../../utils/get-config-from-env.js';
-import { LocalAuthDriver } from './local.js';
-import { isLoginRedirectAllowed } from '../../utils/is-login-redirect-allowed.js';
 import { getSchema } from '../../utils/get-schema.js';
+import { isLoginRedirectAllowed } from '../../utils/is-login-redirect-allowed.js';
+import { LocalAuthDriver } from './local.js';
 // Register the samlify schema validator
 samlify.setSchemaValidator(validator);
 export class SAMLAuthDriver extends LocalAuthDriver {
@@ -117,6 +117,9 @@ export function createSAMLAuthRouter(providerName) {
         const logger = useLogger();
         const relayState = req.body?.RelayState;
         const authMode = (env[`AUTH_${providerName.toUpperCase()}_MODE`] ?? 'session');
+        if (relayState && isLoginRedirectAllowed(relayState, providerName) === false) {
+            throw new InvalidPayloadError({ reason: `URL "${relayState}" can't be used to redirect after login` });
+        }
         try {
             const { sp, idp } = getAuthProvider(providerName);
             const { extract } = await sp.parseLoginResponse(idp, 'post', req);

package/dist/controllers/assets.js

@@ -1,10 +1,12 @@
 import { useEnv } from '@directus/env';
-import { InvalidQueryError, RangeNotSatisfiableError } from '@directus/errors';
+import { InvalidPayloadError, InvalidQueryError, RangeNotSatisfiableError } from '@directus/errors';
 import { TransformationMethods } from '@directus/types';
-import { parseJSON } from '@directus/utils';
+import { getDateTimeFormatted, parseJSON } from '@directus/utils';
 import contentDisposition from 'content-disposition';
 import { Router } from 'express';
 import { merge, pick } from 'lodash-es';
+import * as z from 'zod';
+import { fromZodError } from 'zod-validation-error';
 import { ASSET_TRANSFORM_QUERY_KEYS, SYSTEM_ASSET_ALLOW_LIST } from '../constants.js';
 import getDatabase from '../database/index.js';
 import { useLogger } from '../logger/index.js';
@@ -15,9 +17,44 @@ import asyncHandler from '../utils/async-handler.js';
 import { getCacheControlHeader } from '../utils/get-cache-headers.js';
 import { getConfigFromEnv } from '../utils/get-config-from-env.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
+import { isValidUuid } from '../utils/is-valid-uuid.js';
 const router = Router();
 const env = useEnv();
 router.use(useCollection('directus_files'));
+router.post('/folder/:pk', asyncHandler(async (req, res) => {
+    const service = new AssetsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const { archive, complete, metadata } = await service.zipFolder(req.params['pk']);
+    res.setHeader('Content-Type', 'application/zip');
+    res.setHeader('Content-Disposition', `attachment; filename="folder-${metadata['name'] ? metadata['name'] : 'unknown'}-${getDateTimeFormatted()}.zip"`);
+    archive.pipe(res);
+    await complete();
+}));
+router.post('/files/', asyncHandler(async (req, res) => {
+    const service = new AssetsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const { error, data } = z
+        .object({
+        ids: z
+            .array(z.string().refine((v) => isValidUuid(v), {
+            error: '"id" must be a uuid',
+        }))
+            .min(1),
+    })
+        .safeParse(req.body);
+    if (error) {
+        throw new InvalidPayloadError({ reason: fromZodError(error).message });
+    }
+    const { archive, complete } = await service.zipFiles(data.ids);
+    res.setHeader('Content-Type', 'application/zip');
+    res.setHeader('Content-Disposition', `attachment; filename="files-${getDateTimeFormatted()}.zip"`);
+    archive.pipe(res);
+    await complete();
+}));
 router.get('/:pk/:filename?', 
 // Validate query params
 asyncHandler(async (req, res, next) => {

package/dist/controllers/mcp.js

@@ -1,6 +1,6 @@
 import { ForbiddenError } from '@directus/errors';
 import { Router } from 'express';
-import { DirectusMCP } from '../mcp/index.js';
+import { DirectusMCP } from '../ai/mcp/index.js';
 import { SettingsService } from '../services/settings.js';
 import asyncHandler from '../utils/async-handler.js';
 const router = Router();

package/dist/database/migrations/20240806A-permissions-policies.js

@@ -6,8 +6,8 @@ import { fetchPermissions } from '../../permissions/lib/fetch-permissions.js';
 import { fetchPolicies } from '../../permissions/lib/fetch-policies.js';
 import { fetchRolesTree } from '../../permissions/lib/fetch-roles-tree.js';
 import { getSchema } from '../../utils/get-schema.js';
-import { getSchemaInspector } from '../index.js';
 import { mergePermissions } from '../../permissions/utils/merge-permissions.js';
+import { getSchemaInspector } from '../index.js';
 async function fetchRoleAccess(roles, context) {
     const roleAccess = {
         admin_access: false,
@@ -184,7 +184,7 @@ export async function down(knex) {
     // role permissions to be inserted once all processing is completed
     const rolePermissions = [];
     for (const role of roles) {
-        const roleTree = await fetchRolesTree(role.id, knex);
+        const roleTree = await fetchRolesTree(role.id, { knex });
         let roleAccess = null;
         if (role.id !== null) {
             roleAccess = await fetchRoleAccess(roleTree, context);

package/dist/database/migrations/20251103A-add-ai-settings.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20251103A-add-ai-settings.js

@@ -0,0 +1,14 @@
+export async function up(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.text('ai_openai_api_key');
+        table.text('ai_anthropic_api_key');
+        table.text('ai_system_prompt');
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.dropColumn('ai_openai_api_key');
+        table.dropColumn('ai_anthropic_api_key');
+        table.dropColumn('ai_system_prompt');
+    });
+}

package/dist/database/run-ast/run-ast.js

@@ -48,7 +48,7 @@ export async function runAst(originalAST, schema, accountability, options) {
         if (!rawItems)
             return null;
         // Run the items through the special transforms
-        const payloadService = new PayloadService(collection, { knex, schema });
+        const payloadService = new PayloadService(collection, { accountability, knex, schema });
         let items = await payloadService.processValues('read', rawItems, query.alias ?? {}, query.aggregate ?? {});
         if (!items || (Array.isArray(items) && items.length === 0))
             return items;

package/dist/extensions/lib/installation/manager.js

@@ -63,11 +63,9 @@ export class InstallationManager {
                 }
                 await queue.onIdle();
             }
-            else {
-                // No custom location, so save to regular local extensions folder
-                const dest = join(this.extensionPath, '.registry', versionId);
-                await move(join(tempDir, extractedPath), dest, { overwrite: true });
-            }
+            // move to regular local extensions folder
+            const dest = join(this.extensionPath, '.registry', versionId);
+            await move(join(tempDir, extractedPath), dest, { overwrite: true });
         }
         catch (err) {
             logger.warn(err);
@@ -92,9 +90,7 @@ export class InstallationManager {
             }
             await queue.onIdle();
         }
-        else {
-            const path = join(this.extensionPath, '.registry', folder);
-            await remove(path);
-        }
+        const path = join(this.extensionPath, '.registry', folder);
+        await remove(path);
     }
 }

package/dist/extensions/lib/sync/status.d.ts

@@ -0,0 +1,11 @@
+export declare const SyncStatus: {
+    readonly SYNCING: "SYNCING";
+    readonly IDLE: "IDLE";
+};
+export type SyncStatus = keyof typeof SyncStatus;
+export declare function getSyncStatus(): Promise<SyncStatus>;
+export declare function setSyncStatus(status: SyncStatus): Promise<void>;
+/**
+ * Checks the filesystem lock file if we are currently synchronizing
+ */
+export declare function isSynchronizing(): Promise<boolean>;

package/dist/extensions/lib/sync/status.js

@@ -0,0 +1,34 @@
+/**
+ * Utility functions to write a `.status` file on the filesystem to indicate active synchronization
+ */
+import { join } from 'node:path';
+import { exists } from 'fs-extra';
+import { writeFile, rm } from 'node:fs/promises';
+import { getExtensionsPath } from '../get-extensions-path.js';
+export const SyncStatus = {
+    SYNCING: 'SYNCING',
+    IDLE: 'IDLE',
+};
+export async function getSyncStatus() {
+    const statusFilePath = join(getExtensionsPath(), '.status');
+    if (await exists(statusFilePath)) {
+        return SyncStatus.SYNCING;
+    }
+    return SyncStatus.IDLE;
+}
+export async function setSyncStatus(status) {
+    const statusFilePath = join(getExtensionsPath(), '.status');
+    if (status === SyncStatus.SYNCING) {
+        await writeFile(statusFilePath, '');
+    }
+    else {
+        await rm(statusFilePath);
+    }
+}
+/**
+ * Checks the filesystem lock file if we are currently synchronizing
+ */
+export async function isSynchronizing() {
+    const status = await getSyncStatus();
+    return status === SyncStatus.SYNCING;
+}

package/dist/extensions/lib/sync/sync.d.ts

@@ -0,0 +1,6 @@
+export type ExtensionSyncOptions = {
+    forceSync?: boolean;
+    partialSync?: string;
+    skipSync?: boolean;
+};
+export declare function syncExtensions(options?: ExtensionSyncOptions): Promise<void>;

package/dist/extensions/lib/sync/sync.js

@@ -0,0 +1,90 @@
+import Queue from 'p-queue';
+import mid from 'node-machine-id';
+import { useEnv } from '@directus/env';
+import { createWriteStream } from 'node:fs';
+import { mkdir, rm } from 'node:fs/promises';
+import { pipeline } from 'node:stream/promises';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { getSyncPaths, compareFileMetadata } from './utils.js';
+import { useBus } from '../../../bus/index.js';
+import { SyncFileTracker } from './tracker.js';
+import { useLock } from '../../../lock/index.js';
+import { useLogger } from '../../../logger/index.js';
+import { getStorage } from '../../../storage/index.js';
+import { getExtensionsPath } from '../get-extensions-path.js';
+import { isSynchronizing, setSyncStatus, SyncStatus } from './status.js';
+import { normalizePath } from '@directus/utils';
+export async function syncExtensions(options) {
+    if (options?.skipSync === true)
+        return;
+    const env = useEnv();
+    const lock = useLock();
+    const messenger = useBus();
+    const logger = useLogger();
+    if (options?.forceSync !== true && (await isSynchronizing())) {
+        logger.debug('Extensions are already being synced to this directory from another process.');
+        return;
+    }
+    const machineId = await mid.machineId();
+    const machineKey = `extensions-sync/${machineId}`;
+    const processId = await lock.increment(machineKey);
+    if (processId !== 1) {
+        logger.debug('Extensions are already being synced to this machine from another process.');
+        // Wait until the process that called the lock publishes a message that the syncing is complete
+        return new Promise((resolve) => {
+            messenger.subscribe(machineKey, () => resolve());
+        });
+    }
+    try {
+        logger.debug('Syncing extensions from configured storage location...');
+        // Ensure that the local extensions cache path exists
+        await mkdir(getExtensionsPath(), { recursive: true });
+        await setSyncStatus(SyncStatus.SYNCING);
+        const { localExtensionsPath, remoteExtensionsPath } = getSyncPaths(options?.partialSync);
+        const storage = await getStorage();
+        const disk = storage.location(env['EXTENSIONS_LOCATION']);
+        // check if we are only removing the local directory
+        if (options?.partialSync) {
+            const remoteExists = await disk.exists(normalizePath(join(remoteExtensionsPath, 'package.json')));
+            if (remoteExists === false) {
+                await rm(localExtensionsPath, { recursive: true, force: true });
+                return;
+            }
+        }
+        // Make sure we don't overload the file handles
+        const queue = new Queue({ concurrency: 1000 });
+        // start file tracker
+        const fileTracker = new SyncFileTracker();
+        const localFileCount = await fileTracker.readLocalFiles(localExtensionsPath);
+        const hasLocalFiles = localFileCount > 0;
+        for await (const filepath of disk.list(remoteExtensionsPath)) {
+            // We want files to be stored in the root of `$TEMP_PATH/extensions`, so gotta remove the
+            // extensions path on disk from the start of the file path
+            const relativePath = relative(resolve(sep, remoteExtensionsPath), resolve(sep, filepath));
+            const destinationPath = join(localExtensionsPath, relativePath);
+            await fileTracker.passedFile(relativePath);
+            // No need to check metadata when force is enabled
+            if (options?.forceSync !== true && hasLocalFiles) {
+                const fileUnchanged = await compareFileMetadata(destinationPath, filepath, disk);
+                if (fileUnchanged)
+                    continue;
+            }
+            // Ensure that the directory path exists
+            await mkdir(dirname(destinationPath), { recursive: true });
+            // write remote file to the local filesystem
+            const readStream = await disk.read(filepath);
+            const writeStream = createWriteStream(destinationPath);
+            queue.add(() => pipeline(readStream, writeStream));
+        }
+        // wait for the queue to finish
+        await queue.onIdle();
+        // cleanup dangling local files
+        await fileTracker.cleanup(localExtensionsPath);
+    }
+    finally {
+        // release various locking mechanisms
+        messenger.publish(machineKey, { ready: true });
+        await lock.delete(machineKey);
+        await setSyncStatus(SyncStatus.IDLE);
+    }
+}

package/dist/extensions/lib/sync/tracker.d.ts

@@ -0,0 +1,18 @@
+export declare class SyncFileTracker {
+    private localFiles;
+    private trackedDirs;
+    constructor();
+    /**
+     * Reads all files recusrively in the provided directory
+     * @returns the number of files read
+     */
+    readLocalFiles(localExtensionsPath: string): Promise<number>;
+    /**
+     * Removes a file from the locally tracked files
+     */
+    passedFile(filePath: string): Promise<void>;
+    /**
+     * Removes left over tracked files that were not processed
+     */
+    cleanup(localExtensionsPath: string): Promise<void>;
+}

package/dist/extensions/lib/sync/tracker.js

@@ -0,0 +1,71 @@
+/**
+ * class to help tracking file status between local and remote
+ */
+import { readdir, rm } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { pathDepth } from './utils.js';
+export class SyncFileTracker {
+    localFiles;
+    trackedDirs;
+    constructor() {
+        this.localFiles = new Set();
+        this.trackedDirs = new Set();
+    }
+    /**
+     * Reads all files recusrively in the provided directory
+     * @returns the number of files read
+     */
+    async readLocalFiles(localExtensionsPath) {
+        const entries = await readdir(localExtensionsPath, { recursive: true, withFileTypes: true }).catch(() => {
+            /* path doesnt exist */
+        });
+        if (!entries)
+            return 0;
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const relativePath = join(relative(localExtensionsPath, entry.parentPath), entry.name);
+            this.localFiles.add(relativePath);
+        }
+        return this.localFiles.size;
+    }
+    /**
+     * Removes a file from the locally tracked files
+     */
+    async passedFile(filePath) {
+        this.localFiles.delete(filePath);
+        let currentDir = dirname(filePath);
+        while (currentDir !== '.') {
+            if (this.trackedDirs.has(currentDir))
+                break;
+            this.trackedDirs.add(currentDir);
+            currentDir = dirname(currentDir);
+        }
+    }
+    /**
+     * Removes left over tracked files that were not processed
+     */
+    async cleanup(localExtensionsPath) {
+        const removeDirs = new Set();
+        for (const removeFile of this.localFiles) {
+            if (removeFile === '.status')
+                continue;
+            let currentDir = dirname(removeFile);
+            while (currentDir !== localExtensionsPath && currentDir !== '.') {
+                if (this.trackedDirs.has(currentDir))
+                    break;
+                removeDirs.add(currentDir);
+                currentDir = dirname(currentDir);
+            }
+        }
+        // sort directory by depth so we can remove the highest level directory recursively
+        const removeDirsRecursive = Array.from(removeDirs)
+            .sort((a, b) => pathDepth(b) - pathDepth(a))
+            .filter((d) => !removeDirs.has(dirname(d)));
+        for (const dir of removeDirsRecursive) {
+            const relativePath = join(localExtensionsPath, dir);
+            // removing local folder that does not exist in the remote storage
+            await rm(relativePath, { recursive: true, force: true });
+        }
+    }
+}

package/dist/extensions/lib/sync/utils.d.ts

@@ -0,0 +1,24 @@
+import type { Driver } from '@directus/storage';
+/**
+ * Returns the directory depth of the provided path
+ */
+export declare function pathDepth(path: string): number;
+/**
+ * Reads the size and modified date of a file if it exists
+ */
+export declare function fsStat(path: string): Promise<{
+    size: number;
+    modified: Date;
+} | null>;
+/**
+ * Builds up the local and remote paths to use with syncing
+ */
+export declare function getSyncPaths(partialPath: string | undefined): {
+    localExtensionsPath: string;
+    remoteExtensionsPath: string;
+};
+/**
+ * Retrieve the stats for local and remote files and check if they are the same
+ * Returns false if files are differnt else true
+ */
+export declare function compareFileMetadata(localPath: string, remotePath: string, disk: Driver): Promise<boolean>;

package/dist/extensions/lib/sync/utils.js

@@ -0,0 +1,62 @@
+import { join, relative, resolve, sep } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { getExtensionsPath } from '../get-extensions-path.js';
+import { useEnv } from '@directus/env';
+import { normalizePath } from '@directus/utils';
+/**
+ * Returns the directory depth of the provided path
+ */
+export function pathDepth(path) {
+    let count = 0;
+    for (let i = 0; i < path.length; i++) {
+        if (path[i] === sep)
+            count++;
+    }
+    return count;
+}
+/**
+ * Reads the size and modified date of a file if it exists
+ */
+export async function fsStat(path) {
+    const data = await stat(path, { bigint: false }).catch(() => {
+        /* file not available */
+    });
+    if (!data)
+        return null;
+    return {
+        size: data.size,
+        modified: data.mtime,
+    };
+}
+/**
+ * Builds up the local and remote paths to use with syncing
+ */
+export function getSyncPaths(partialPath) {
+    const env = useEnv();
+    const localRootPath = getExtensionsPath();
+    const remoteRootPath = env['EXTENSIONS_PATH'];
+    if (!partialPath) {
+        return {
+            localExtensionsPath: localRootPath,
+            remoteExtensionsPath: normalizePath(remoteRootPath),
+        };
+    }
+    const resolvedPartialPath = relative(sep, resolve(sep, partialPath));
+    return {
+        localExtensionsPath: join(localRootPath, resolvedPartialPath),
+        remoteExtensionsPath: normalizePath(join(remoteRootPath, resolvedPartialPath)),
+    };
+}
+/**
+ * Retrieve the stats for local and remote files and check if they are the same
+ * Returns false if files are differnt else true
+ */
+export async function compareFileMetadata(localPath, remotePath, disk) {
+    const localStat = await fsStat(localPath).catch(() => { });
+    if (!localStat)
+        return false;
+    const remoteStat = await disk.stat(remotePath).catch(() => { });
+    if (!remoteStat)
+        return false;
+    return remoteStat.modified <= localStat.modified && remoteStat.size === localStat.size;
+}

package/dist/extensions/manager.d.ts

@@ -1,6 +1,7 @@
 import type { Extension, ExtensionManagerOptions } from '@directus/types';
 import { Router } from 'express';
 import type { ReadStream } from 'node:fs';
+import { type ExtensionSyncOptions } from './lib/sync/sync.js';
 export declare class ExtensionManager {
     private options;
     /**
@@ -47,6 +48,10 @@ export declare class ExtensionManager {
      * sequence.
      */
     private reloadQueue;
+    /**
+     * Used to prevent race condition when reading extension data while reloading extensions
+     */
+    private reloadPromise;
     /**
      * Optional file system watcher to auto-reload extensions when the local file system changes
      */
@@ -76,7 +81,7 @@ export declare class ExtensionManager {
      */
     install(versionId: string): Promise<void>;
     uninstall(folder: string): Promise<void>;
-    broadcastReloadNotification(): Promise<void>;
+    broadcastReloadNotification(options?: ExtensionSyncOptions): Promise<void>;
     /**
      * Load all extensions from disk and register them in their respective places
      */
@@ -88,9 +93,8 @@ export declare class ExtensionManager {
     /**
      * Reload all the extensions. Will unload if extensions have already been loaded
      */
-    reload(options?: {
-        forceSync: boolean;
-    }): Promise<unknown>;
+    reload(options?: ExtensionSyncOptions): Promise<unknown>;
+    isReloading(): Promise<void>;
     /**
      * Return the previously generated app extension bundle chunk by name.
      * Providing no name will return the entry bundle.