@nocobase/server 2.0.0-beta.8 → 2.0.0

package/lib/app-supervisor/main-only-adapter.d.ts

@@ -0,0 +1,37 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import Application from '../application';
+import type { AppDiscoveryAdapter, AppProcessAdapter, AppStatus, GetAppOptions } from './types';
+import type { AppSupervisor } from './index';
+/** Minimal single-process adapter only for booting the main application. */
+export declare class MainOnlyAdapter implements AppDiscoveryAdapter, AppProcessAdapter {
+    protected readonly supervisor: AppSupervisor;
+    readonly name: string;
+    app: Application;
+    status: AppStatus;
+    appErrors: Record<string, Error>;
+    constructor(supervisor: AppSupervisor);
+    getApp(appName: string, options?: GetAppOptions): Promise<Application<import("../application").DefaultState, import("../application").DefaultContext>>;
+    bootstrapApp(appName: string): Promise<void>;
+    addApp(app: Application): Application<import("../application").DefaultState, import("../application").DefaultContext>;
+    getApps(): Application<import("../application").DefaultState, import("../application").DefaultContext>[];
+    hasApp(appName: string): boolean;
+    startApp(appName: string): Promise<void>;
+    stopApp(appName: string): Promise<void>;
+    removeApp(appName: string): Promise<void>;
+    upgradeApp(appName: string): Promise<void>;
+    removeAllApps(): Promise<void>;
+    setAppStatus(appName: string, status: AppStatus, options?: {}): void;
+    getAppStatus(appName: string, defaultStatus?: AppStatus): AppStatus;
+    hasAppError(appName: string): boolean;
+    setAppError(appName: string, error: Error): void;
+    clearAppError(appName: string): void;
+    setAppLastSeenAt(): void;
+    getAppLastSeenAt(appName: string): any;
+}

package/lib/app-supervisor/main-only-adapter.js

@@ -0,0 +1,156 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var main_only_adapter_exports = {};
+__export(main_only_adapter_exports, {
+  MainOnlyAdapter: () => MainOnlyAdapter
+});
+module.exports = __toCommonJS(main_only_adapter_exports);
+const _MainOnlyAdapter = class _MainOnlyAdapter {
+  constructor(supervisor) {
+    this.supervisor = supervisor;
+    this.name = "main-only";
+  }
+  name;
+  app;
+  status;
+  appErrors = {};
+  async getApp(appName, options = {}) {
+    if (appName !== "main") {
+      this.supervisor.logger.warn(`only main app is supported`, { method: "getApp", appName });
+      return;
+    }
+    if (!options.withOutBootStrap) {
+      await this.bootstrapApp(appName);
+    }
+    return this.app;
+  }
+  async bootstrapApp(appName) {
+    if (appName !== "main" || !this.app) {
+      this.setAppStatus(appName, "not_found");
+      return;
+    }
+    const status = this.getAppStatus("main");
+    if (this.hasApp(appName) && status && status !== "preparing") {
+      return;
+    }
+    this.setAppStatus("main", "initializing");
+    this.setAppStatus("main", "initialized");
+  }
+  addApp(app) {
+    if (app.name !== "main") {
+      this.supervisor.logger.warn(`only main app is supported`, { method: "addApp" });
+      return;
+    }
+    if (this.app) {
+      throw new Error(`app ${app.name} already exists`);
+    }
+    this.app = app;
+    if (!this.status || this.status === "not_found") {
+      this.setAppStatus(app.name, "preparing");
+    }
+    return app;
+  }
+  getApps() {
+    return [this.app];
+  }
+  hasApp(appName) {
+    if (appName !== "main") {
+      return false;
+    }
+    return !!this.app;
+  }
+  async startApp(appName) {
+    if (appName !== "main") {
+      this.supervisor.logger.warn(`only main app is supported`, { method: "startApp" });
+      return;
+    }
+    const app = await this.getApp(appName, { withOutBootStrap: true });
+    await (app == null ? void 0 : app.runCommand("start", "--quickstart"));
+  }
+  async stopApp(appName) {
+    if (appName !== "main") {
+      this.supervisor.logger.warn(`only main app is supported`, { method: "stopApp" });
+      return;
+    }
+    await this.app.runCommand("stop");
+  }
+  async removeApp(appName) {
+    if (appName !== "main") {
+      this.supervisor.logger.warn(`only main app is supported`, { method: "removeApp" });
+      return;
+    }
+    if (!this.app) {
+      return;
+    }
+    await this.app.runCommand("destroy");
+  }
+  async upgradeApp(appName) {
+    if (appName !== "main") {
+      this.supervisor.logger.warn(`only main app is supported`, { method: "upgrade" });
+      return;
+    }
+    if (!this.app) {
+      return;
+    }
+    await this.app.runCommand("upgrade");
+  }
+  async removeAllApps() {
+    return this.removeApp("main");
+  }
+  setAppStatus(appName, status, options = {}) {
+    if (this.status === status) {
+      return;
+    }
+    this.status = status;
+    this.supervisor.emit("appStatusChanged", { appName, status, options });
+  }
+  getAppStatus(appName, defaultStatus) {
+    return this.status ?? defaultStatus ?? null;
+  }
+  hasAppError(appName) {
+    return !!this.appErrors[appName];
+  }
+  setAppError(appName, error) {
+    this.appErrors[appName] = error;
+    this.supervisor.emit("appError", { appName, error });
+  }
+  clearAppError(appName) {
+    this.appErrors[appName] = null;
+  }
+  setAppLastSeenAt() {
+  }
+  getAppLastSeenAt(appName) {
+    return null;
+  }
+};
+__name(_MainOnlyAdapter, "MainOnlyAdapter");
+let MainOnlyAdapter = _MainOnlyAdapter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MainOnlyAdapter
+});

package/lib/app-supervisor/types.d.ts

@@ -0,0 +1,161 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+import { IDatabaseOptions, Transaction, Transactionable } from '@nocobase/database';
+import type Application from '../application';
+import type { AppSupervisor } from './index';
+import type { IncomingMessage, ServerResponse } from 'http';
+/**
+ * Options accepted by discovery adapter when loading an application.
+ */
+export type GetAppOptions = {
+    withOutBootStrap?: boolean;
+    [key: string]: any;
+};
+/**
+ * Parameters supplied to a bootstrapper when a sub-application is being started.
+ */
+export type BootOptions = {
+    appName: string;
+    options: Record<string, any>;
+    appSupervisor: AppSupervisor;
+};
+/**
+ * Callback used by process adapters to lazily initialize applications.
+ */
+export type AppBootstrapper = (bootOptions: BootOptions) => Promise<void>;
+/**
+ * All supported lifecycle states of a managed application.
+ */
+export type AppStatus = 'preparing' | 'initializing' | 'initialized' | 'running' | 'commanding' | 'stopped' | 'error' | 'not_found';
+/**
+ * Metadata representing a deployable environment (container, pod, VM, etc.).
+ */
+export type EnvironmentInfo = {
+    name: string;
+    url?: string;
+    proxyUrl?: string;
+    available?: boolean;
+    appVersion?: string;
+    lastHeartbeatAt?: number;
+};
+export type BootstrapLock = {
+    acquire: () => Promise<boolean>;
+    release: () => Promise<void>;
+};
+export type AppModelOptions = {
+    dbConnType?: 'new_database' | 'new_connection' | 'new_schema' | string;
+    database?: IDatabaseOptions;
+    [key: string]: any;
+};
+export type AppModel = {
+    name: string;
+    cname?: string;
+    environment?: string;
+    environments?: string[];
+    options: AppModelOptions;
+};
+export type ProcessCommand = {
+    requestId: string;
+    appName: string;
+    action: 'create' | 'start' | 'stop' | 'remove' | string;
+    environments: string[];
+    payload?: Record<string, any>;
+};
+export type AppDbCreatorOptions = Transactionable & {
+    app: Application;
+    appOptions: AppModelOptions;
+};
+export type AppDbCreator = (options: AppDbCreatorOptions) => Promise<void>;
+export type AppOptionsFactory = (appName: string, mainApp: Application, options?: AppModelOptions) => any;
+/**
+ * Abstraction for discovering applications across deployment environments.
+ */
+export type AppStatusesResult = Record<string, AppStatus | Record<string, AppStatus> | null>;
+export interface AppDiscoveryAdapter {
+    readonly name: string;
+    readonly environmentName?: string;
+    readonly environmentUrl?: string;
+    readonly environmentProxyUrl?: string;
+    readonly appStatus?: Record<string, AppStatus>;
+    readonly lastSeenAt?: Map<string, number>;
+    /**
+     * Update the "last seen at" timestamp for an application.
+     */
+    setAppLastSeenAt(appName: string): void | Promise<void>;
+    getAppLastSeenAt(appName: string): number | null | Promise<number | null>;
+    /**
+     * Read the cached lifecycle status for a given application.
+     */
+    getAppStatus(appName: string, defaultStatus?: AppStatus): Promise<AppStatus | null> | AppStatus | null;
+    /**
+     * Persist an application's lifecycle status back to the discovery backend.
+     */
+    setAppStatus(appName: string, status: AppStatus, options?: Record<string, any>): void | Promise<void>;
+    clearAppStatus?(appName: string): void | Promise<void>;
+    loadAppModels?(mainApp: Application): Promise<void>;
+    getAppsStatuses?(appNames?: string[]): Promise<AppStatusesResult> | AppStatusesResult;
+    addAutoStartApps?(environmentName: string, appName: string[]): Promise<void>;
+    getAutoStartApps?(environmentName: string): Promise<string[]>;
+    removeAutoStartApps?(environmentName: string, appNames: string[]): Promise<void>;
+    addAppModel?(appModel: AppModel): Promise<void>;
+    getAppModel?(appName: string): Promise<AppModel>;
+    removeAppModel?(appName: string): Promise<void>;
+    getAppNameByCName?(cname: string): Promise<string | null>;
+    registerEnvironment?(environment: EnvironmentInfo): Promise<boolean>;
+    unregisterEnvironment?(): Promise<void>;
+    listEnvironments?(): Promise<EnvironmentInfo[]>;
+    getEnvironment?(environmentName: string): Promise<EnvironmentInfo | null>;
+    heartbeatEnvironment?(): Promise<void>;
+    getBootstrapLock?(appName: string): Promise<BootstrapLock | null> | BootstrapLock | null;
+    proxyWeb?(appName: string, req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+    proxyWs?(req: IncomingMessage, socket: any, head: Buffer): Promise<boolean>;
+    dispose?(): Promise<void>;
+}
+export interface AppProcessAdapter {
+    readonly name: string;
+    readonly apps?: Record<string, Application>;
+    readonly appErrors?: Record<string, Error>;
+    readonly lastMaintainingMessage?: Record<string, string>;
+    readonly statusBeforeCommanding?: Record<string, AppStatus>;
+    addApp(app: Application): void;
+    getApp(appName: string, options?: GetAppOptions): Promise<Application>;
+    hasApp(appName: string): boolean;
+    bootstrapApp(appName: string): Promise<void>;
+    getApps?(): Application[];
+    createApp?(options: {
+        appModel: AppModel;
+        mainApp?: Application;
+        transaction?: Transaction;
+    }, context?: {
+        requestId: string;
+    }): Promise<void>;
+    startApp?(appName: string, context?: {
+        requestId: string;
+    }): Promise<void>;
+    stopApp?(appName: string, context?: {
+        requestId: string;
+    }): Promise<void>;
+    removeApp?(appName: string, context?: {
+        requestId: string;
+    }): Promise<void>;
+    upgradeApp?(appName: string, context?: {
+        requestId: string;
+    }): Promise<void>;
+    removeAllApps?(): Promise<void>;
+    setAppError?(appName: string, error: Error): void;
+    hasAppError?(appName: string): boolean;
+    clearAppError?(appName: string): void;
+}
+export interface AppCommandAdapter {
+    dispatchCommand(command: ProcessCommand): Promise<void>;
+    registerCommandHandler(mainApp: Application): void;
+    dispose?(): Promise<void>;
+}

package/lib/app-supervisor/types.js

@@ -0,0 +1,24 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/application.d.ts

@@ -15,6 +15,7 @@ import Database, { CollectionOptions, IDatabaseOptions } from '@nocobase/databas
 import { Logger, LoggerOptions, RequestLoggerOptions, SystemLogger, SystemLoggerOptions } from '@nocobase/logger';
 import { ResourceOptions, Resourcer } from '@nocobase/resourcer';
 import { Telemetry, TelemetryOptions } from '@nocobase/telemetry';
+import { AIManager } from '@nocobase/ai';
 import { LockManager, LockManagerOptions } from '@nocobase/lock-manager';
 import { AsyncEmitter, ToposortOptions } from '@nocobase/utils';
 import { Command, CommandOptions, ParseOptions } from 'commander';
@@ -180,6 +181,7 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     redisConnectionManager: RedisConnectionManager;
     workerIdAllocator: WorkerIdAllocator;
     snowflakeIdGenerator: SnowflakeIdGenerator;
+    aiManager: AIManager;
     pubSubManager: PubSubManager;
     syncMessageManager: SyncMessageManager;
     requestLogger: Logger;
@@ -279,7 +281,7 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     /**
      * @internal
      */
-    setMaintaining(_maintainingCommandStatus: MaintainingCommandStatus): void;
+    setMaintaining(_maintainingCommandStatus: MaintainingCommandStatus): Promise<void>;
     /**
      * @internal
      */

package/lib/application.js

@@ -49,6 +49,7 @@ var import_data_source_manager = require("@nocobase/data-source-manager");
 var import_database = __toESM(require("@nocobase/database"));
 var import_logger = require("@nocobase/logger");
 var import_telemetry = require("@nocobase/telemetry");
+var import_ai = require("@nocobase/ai");
 var import_lock_manager = require("@nocobase/lock-manager");
 var import_snowflake_id = require("@nocobase/snowflake-id");
 var import_utils = require("@nocobase/utils");
@@ -128,6 +129,7 @@ const _Application = class _Application extends import_koa.default {
   redisConnectionManager;
   workerIdAllocator;
   snowflakeIdGenerator;
+  aiManager;
   pubSubManager;
   syncMessageManager;
   requestLogger;
@@ -316,9 +318,9 @@ const _Application = class _Application extends import_koa.default {
   /**
    * @internal
    */
-  setMaintaining(_maintainingCommandStatus) {
+  async setMaintaining(_maintainingCommandStatus) {
     this._maintainingCommandStatus = _maintainingCommandStatus;
-    this.emit("maintaining", _maintainingCommandStatus);
+    await this.emitAsync("maintaining", _maintainingCommandStatus);
     if (_maintainingCommandStatus.status == "command_end") {
       this._maintaining = false;
       return;
@@ -610,7 +612,7 @@ const _Application = class _Application extends import_koa.default {
         await this.pm.loadCommands();
       }
       const command = await this.cli.parseAsync(argv, options);
-      this.setMaintaining({
+      await this.setMaintaining({
         status: "command_end",
         command: this.activatedCommand
       });
@@ -621,7 +623,7 @@ const _Application = class _Application extends import_koa.default {
           name: "unknown"
         };
       }
-      this.setMaintaining({
+      await this.setMaintaining({
         status: "command_error",
         command: this.activatedCommand,
         error
@@ -843,11 +845,11 @@ const _Application = class _Application extends import_koa.default {
       this.activatedCommand = {
         name: (0, import_helper.getCommandFullName)(actionCommand)
       };
-      this.setMaintaining({
+      await this.setMaintaining({
         status: "command_begin",
         command: this.activatedCommand
       });
-      this.setMaintaining({
+      await this.setMaintaining({
         status: "command_running",
         command: this.activatedCommand
       });
@@ -917,6 +919,7 @@ const _Application = class _Application extends import_koa.default {
     this._env = new import_environment.Environment();
     this._cli = this.createCLI();
     this._i18n = (0, import_helper.createI18n)(options);
+    this.aiManager = new import_ai.AIManager(this);
     this.pubSubManager = (0, import_pub_sub_manager.createPubSubManager)(this, options.pubSubManager);
     this.syncMessageManager = new import_sync_message_manager.SyncMessageManager(this, options.syncMessageManager);
     this.eventQueue = new import_event_queue.EventQueue(this, options.eventQueue);
@@ -981,6 +984,7 @@ const _Application = class _Application extends import_koa.default {
     for (const callback of _Application.staticCommands) {
       callback(this);
     }
+    this.aiManager = new import_ai.AIManager(this);
   }
   createMainDataSource(options) {
     const mainDataSourceInstance = new import_main_data_source.MainDataSource({

package/lib/commands/ai.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type Application from '../application';
+declare const _default: (app: Application) => void;
+export default _default;

package/lib/commands/ai.js

@@ -0,0 +1,40 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ai_exports = {};
+__export(ai_exports, {
+  default: () => ai_default
+});
+module.exports = __toCommonJS(ai_exports);
+var import_create_docs_index = require("../ai/create-docs-index");
+var ai_default = /* @__PURE__ */ __name((app) => {
+  const ai = app.command("ai");
+  ai.command("create-docs-index").option("--pkg [pkg]", "Generate docs index for the specified plugin package (comma separated).").action(async (...cliArgs) => {
+    const [opts] = cliArgs;
+    await (0, import_create_docs_index.createDocsIndex)(app, opts);
+  });
+}, "default");

package/lib/commands/console.js

@@ -31,9 +31,9 @@ __export(console_exports, {
 });
 module.exports = __toCommonJS(console_exports);
 /* istanbul ignore file -- @preserve */
-const REPL = require("repl");
 var console_default = /* @__PURE__ */ __name((app) => {
   app.command("console").preload().action(async () => {
+    const REPL = require("repl");
     await app.start();
     const repl = REPL.start("nocobase > ").context.app = app;
     repl.on("exit", async function(err) {

package/lib/commands/index.js

@@ -54,6 +54,7 @@ var import_stop = __toESM(require("./stop"));
 var import_upgrade = __toESM(require("./upgrade"));
 var import_console = __toESM(require("./console"));
 var import_repair = __toESM(require("./repair"));
+var import_ai = __toESM(require("./ai"));
 /* istanbul ignore file -- @preserve */
 function registerCli(app) {
   (0, import_console.default)(app);
@@ -70,6 +71,7 @@ function registerCli(app) {
   (0, import_start.default)(app);
   (0, import_refresh.default)(app);
   (0, import_repair.default)(app);
+  (0, import_ai.default)(app);
   app.command("build").argument("[packages...]");
   app.command("clean");
   app.command("dev").usage("[options]").option("-p, --port [port]").option("--client").option("--server");

package/lib/commands/install.js

@@ -30,12 +30,14 @@ __export(install_exports, {
   default: () => install_default
 });
 module.exports = __toCommonJS(install_exports);
+var import_create_docs_index = require("../ai/create-docs-index");
 /* istanbul ignore file -- @preserve */
 var install_default = /* @__PURE__ */ __name((app) => {
   app.command("install").ipc().auth().option("-f, --force").option("-c, --clean").option("--lang <lang>").action(async (options) => {
     if (options.lang) {
       process.env.INIT_APP_LANG = options.lang;
     }
+    await (0, import_create_docs_index.createDocsIndex)(app);
     await app.install(options);
     const reinstall = options.clean || options.force;
     app.log.info(`app ${reinstall ? "reinstalled" : "installed"} successfully [v${app.getVersion()}]`);

package/lib/commands/start.js

@@ -42,6 +42,7 @@ __export(start_exports, {
 module.exports = __toCommonJS(start_exports);
 var import_fs_extra = __toESM(require("fs-extra"));
 var import_path = require("path");
+var import_create_docs_index = require("../ai/create-docs-index");
 var import_application_not_install = require("../errors/application-not-install");
 /* istanbul ignore file -- @preserve */
 var start_default = /* @__PURE__ */ __name((app) => {
@@ -52,6 +53,7 @@ var start_default = /* @__PURE__ */ __name((app) => {
     if (upgrading) {
       if (!process.env.VITEST) {
         if (await app.isInstalled()) {
+          await (0, import_create_docs_index.createDocsIndex)(app);
           await app.upgrade();
         }
       }
@@ -60,6 +62,7 @@ var start_default = /* @__PURE__ */ __name((app) => {
       } catch (error) {
       }
     } else if (options.quickstart) {
+      await (0, import_create_docs_index.createDocsIndex)(app);
       if (await app.isInstalled()) {
         await app.upgrade({ quickstart: true });
       } else {

package/lib/commands/upgrade.js

@@ -30,9 +30,11 @@ __export(upgrade_exports, {
   default: () => upgrade_default
 });
 module.exports = __toCommonJS(upgrade_exports);
+var import_create_docs_index = require("../ai/create-docs-index");
 /* istanbul ignore file -- @preserve */
 var upgrade_default = /* @__PURE__ */ __name((app) => {
   app.command("upgrade").ipc().auth().action(async (options) => {
+    await (0, import_create_docs_index.createDocsIndex)(app);
     await app.upgrade(options);
     app.log.info(`\u2728  NocoBase has been upgraded to v${app.getVersion()}`);
   });

package/lib/gateway/errors.js

@@ -100,7 +100,7 @@ const errors = {
   },
   APP_STOPPED: {
     status: 503,
-    message: /* @__PURE__ */ __name(({ app }) => `application ${getAppName(app)} is stopped`, "message"),
+    message: /* @__PURE__ */ __name(({ app, appName }) => `application ${appName || getAppName(app)} is stopped`, "message"),
     maintaining: true
   },
   APP_INITIALIZED: {