@nocobase/server 0.19.0-alpha.1 → 0.19.0-alpha.10

package/lib/app-supervisor.js

@@ -213,9 +213,17 @@ const _AppSupervisor = class _AppSupervisor extends import_events.EventEmitter {
     });
     app.on("__started", async (_app, options) => {
       const { maintainingStatus, options: startOptions } = options;
-      if (maintainingStatus && ["install", "upgrade", "pm.add", "pm.update", "pm.enable", "pm.disable", "pm.remove", "restore"].includes(
-        maintainingStatus.command.name
-      ) && !startOptions.recover) {
+      if (maintainingStatus && [
+        "install",
+        "upgrade",
+        "refresh",
+        "restore",
+        "pm.add",
+        "pm.update",
+        "pm.enable",
+        "pm.disable",
+        "pm.remove"
+      ].includes(maintainingStatus.command.name) && !startOptions.recover) {
         this.setAppStatus(app.name, "running", {
           refresh: true
         });

package/lib/application.js

@@ -498,20 +498,30 @@ const _Application = class _Application extends import_koa.default {
     this.emit("__restarted", this, options);
   }
   async stop(options = {}) {
-    this.log.debug("stop app...", { method: "stop" });
+    const log = options.logging === false ? {
+      debug() {
+      },
+      warn() {
+      },
+      info() {
+      },
+      error() {
+      }
+    } : this.log;
+    log.debug("stop app...", { method: "stop" });
     this.setMaintainingMessage("stopping app...");
     if (this.stopped) {
-      this.log.warn(`app is stopped`, { method: "stop" });
+      log.warn(`app is stopped`, { method: "stop" });
       return;
     }
     await this.emitAsync("beforeStop", this, options);
     try {
       if (!this.db.closed()) {
-        this.log.info(`close db`, { method: "stop" });
+        log.info(`close db`, { method: "stop" });
         await this.db.close();
       }
     } catch (e) {
-      this.log.error(e.message, { method: "stop", err: e.stack });
+      log.error(e.message, { method: "stop", err: e.stack });
     }
     if (this.cacheManager) {
       await this.cacheManager.close();
@@ -521,7 +531,7 @@ const _Application = class _Application extends import_koa.default {
     }
     await this.emitAsync("afterStop", this, options);
     this.stopped = true;
-    this.log.info(`app has stopped`, { method: "stop" });
+    log.info(`app has stopped`, { method: "stop" });
     this._started = false;
   }
   async destroy(options = {}) {

package/lib/commands/index.js

@@ -38,6 +38,7 @@ var import_db_sync = __toESM(require("./db-sync"));
 var import_destroy = __toESM(require("./destroy"));
 var import_install = __toESM(require("./install"));
 var import_pm = __toESM(require("./pm"));
+var import_refresh = __toESM(require("./refresh"));
 var import_restart = __toESM(require("./restart"));
 var import_start = __toESM(require("./start"));
 var import_stop = __toESM(require("./stop"));
@@ -54,6 +55,7 @@ function registerCli(app) {
   (0, import_stop.default)(app);
   (0, import_destroy.default)(app);
   (0, import_start.default)(app);
+  (0, import_refresh.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

@@ -22,7 +22,10 @@ __export(install_exports, {
 });
 module.exports = __toCommonJS(install_exports);
 var install_default = /* @__PURE__ */ __name((app) => {
-  app.command("install").ipc().auth().option("-f, --force").option("-c, --clean").action(async (options) => {
+  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 app.install(options);
     const reinstall = options.clean || options.force;
     app.log.info(`app ${reinstall ? "reinstalled" : "installed"} successfully [v${app.getVersion()}]`);

package/lib/commands/pm.js

@@ -35,8 +35,8 @@ var import_lodash = __toESM(require("lodash"));
 var import_plugin_command_error = require("../errors/plugin-command-error");
 var pm_default = /* @__PURE__ */ __name((app) => {
   const pm = app.command("pm");
-  pm.command("create").ipc().arguments("plugin").action(async (plugin) => {
-    await app.pm.create(plugin);
+  pm.command("create").arguments("plugin").option("--force-recreate").action(async (plugin, options) => {
+    await app.pm.create(plugin, options);
   });
   pm.command("add").ipc().preload().argument("<pkg>").option("--registry [registry]").option("--auth-token [authToken]").option("--version [version]").action(async (name, options, cli) => {
     try {
@@ -69,7 +69,7 @@ var pm_default = /* @__PURE__ */ __name((app) => {
       throw new import_plugin_command_error.PluginCommandError(`Failed to disable plugin: ${error.message}`);
     }
   });
-  pm.command("remove").ipc().preload().arguments("<plugins...>").action(async (plugins) => {
-    await app.pm.remove(plugins);
+  pm.command("remove").auth().arguments("<plugins...>").option("--force").option("--remove-dir").action(async (plugins, options) => {
+    await app.pm.remove(plugins, options);
   });
 }, "default");

package/lib/commands/refresh.d.ts

@@ -0,0 +1,3 @@
+import Application from '../application';
+declare const _default: (app: Application) => void;
+export default _default;

package/lib/commands/refresh.js

@@ -0,0 +1,31 @@
+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 refresh_exports = {};
+__export(refresh_exports, {
+  default: () => refresh_default
+});
+module.exports = __toCommonJS(refresh_exports);
+var refresh_default = /* @__PURE__ */ __name((app) => {
+  app.command("refresh").ipc().action(async (cliArgs) => {
+    await app.restart({
+      cliArgs
+    });
+    app.log.info("refreshing...");
+  });
+}, "default");

package/lib/gateway/index.d.ts

@@ -66,5 +66,6 @@ export declare class Gateway extends EventEmitter {
     tryConnectToIPCServer(): Promise<false | IPCSocketClient>;
     getIPCSocketClient(): Promise<IPCSocketClient>;
     close(): void;
+    static getIPCSocketClient(): Promise<false | IPCSocketClient>;
 }
 export {};

package/lib/gateway/index.js

@@ -51,7 +51,6 @@ var import_path = require("path");
 var import_qs = __toESM(require("qs"));
 var import_serve_handler = __toESM(require("serve-handler"));
 var import_url = require("url");
-var import_xpipe = __toESM(require("xpipe"));
 var import_app_supervisor = require("../app-supervisor");
 var import_plugin_manager = require("../plugin-manager");
 var import_errors = require("./errors");
@@ -69,13 +68,13 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
   port = process.env.APP_PORT ? parseInt(process.env.APP_PORT) : null;
   host = "0.0.0.0";
   wsServer;
-  socketPath = import_xpipe.default.eq((0, import_path.resolve)(process.cwd(), "storage", "gateway.sock"));
+  socketPath = (0, import_path.resolve)(process.cwd(), "storage", "gateway.sock");
   loggers = new import_utils.Registry();
   constructor() {
     super();
     this.reset();
     if (process.env.SOCKET_PATH) {
-      this.socketPath = import_xpipe.default.eq((0, import_path.resolve)(process.cwd(), process.env.SOCKET_PATH));
+      this.socketPath = (0, import_path.resolve)(process.cwd(), process.env.SOCKET_PATH);
     }
   }
   static getInstance(options = {}) {
@@ -267,7 +266,7 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
       if (ipcClient) {
         const response = await ipcClient.write({ type: "passCliArgv", payload: { argv: process.argv } });
         ipcClient.close();
-        if (response.type !== "error" || response.payload.message !== "Not handle by ipc server") {
+        if (!["error", "not_found"].includes(response.type)) {
           return;
         }
       }
@@ -276,16 +275,20 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
       await (0, import_plugin_symlink.createStoragePluginsSymlink)();
     }
     const mainApp = import_app_supervisor.AppSupervisor.getInstance().bootMainApp(options.mainAppOptions);
-    await mainApp.load();
     mainApp.runAsCLI(process.argv, {
       throwError: true,
       from: "node"
     }).then(async () => {
       if (!await mainApp.isStarted()) {
-        await mainApp.stop();
+        await mainApp.stop({ logging: false });
+      }
+    }).catch(async (e) => {
+      if (e.code !== "commander.helpDisplayed") {
+        mainApp.log.error(e);
+      }
+      if (!await mainApp.isStarted()) {
+        await mainApp.stop({ logging: false });
       }
-    }).catch((e) => {
-      console.error(e);
     });
   }
   isStart() {
@@ -325,7 +328,7 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     this.wsServer = new import_ws_server.WSServer();
     this.server.on("upgrade", (request, socket, head) => {
       const { pathname } = (0, import_url.parse)(request.url);
-      if (pathname === "/ws") {
+      if (pathname === process.env.WS_PATH) {
         this.wsServer.wss.handleUpgrade(request, socket, head, (ws) => {
           this.wsServer.wss.emit("connection", ws, request);
         });
@@ -356,6 +359,14 @@ const _Gateway = class _Gateway extends import_events.EventEmitter {
     (_a = this.server) == null ? void 0 : _a.close();
     (_b = this.wsServer) == null ? void 0 : _b.close();
   }
+  static async getIPCSocketClient() {
+    const socketPath = (0, import_path.resolve)(process.cwd(), process.env.SOCKET_PATH || "storage/gateway.sock");
+    try {
+      return await import_ipc_socket_client.IPCSocketClient.getConnection(socketPath);
+    } catch (error) {
+      return false;
+    }
+  }
 };
 __name(_Gateway, "Gateway");
 __publicField(_Gateway, "instance");

package/lib/gateway/ipc-socket-client.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import net from 'net';
-import * as events from 'events';
 import { Logger } from '@nocobase/logger';
+import * as events from 'events';
+import net from 'net';
 export declare const writeJSON: (socket: net.Socket, data: object) => void;
 export declare class IPCSocketClient extends events.EventEmitter {
     client: net.Socket;

package/lib/gateway/ipc-socket-client.js

@@ -32,9 +32,10 @@ __export(ipc_socket_client_exports, {
   writeJSON: () => writeJSON
 });
 module.exports = __toCommonJS(ipc_socket_client_exports);
-var import_net = __toESM(require("net"));
-var events = __toESM(require("events"));
 var import_logger = require("@nocobase/logger");
+var events = __toESM(require("events"));
+var import_net = __toESM(require("net"));
+var import_xpipe = __toESM(require("xpipe"));
 const writeJSON = /* @__PURE__ */ __name((socket, data) => {
   socket.write(JSON.stringify(data) + "\n", "utf8");
 }, "writeJSON");
@@ -59,7 +60,7 @@ const _IPCSocketClient = class _IPCSocketClient extends events.EventEmitter {
   }
   static async getConnection(serverPath) {
     return new Promise((resolve, reject) => {
-      const client = import_net.default.createConnection({ path: serverPath }, () => {
+      const client = import_net.default.createConnection({ path: import_xpipe.default.eq(serverPath) }, () => {
         resolve(new _IPCSocketClient(client));
       });
       client.on("error", (err) => {
@@ -69,6 +70,8 @@ const _IPCSocketClient = class _IPCSocketClient extends events.EventEmitter {
   }
   async handleServerMessage({ reqId, type, payload }) {
     switch (type) {
+      case "not_found":
+        break;
       case "error":
         this.logger.error({ reqId, message: `${payload.message}|${payload.stack}` });
         break;

package/lib/gateway/ipc-socket-server.d.ts

@@ -8,6 +8,6 @@ export declare class IPCSocketServer {
         reqId: any;
         type: any;
         payload: any;
-    }): Promise<import("../app-command").AppCommand>;
+    }): Promise<string | false | import("../app-command").AppCommand>;
     close(): void;
 }

package/lib/gateway/ipc-socket-server.js

@@ -31,12 +31,13 @@ __export(ipc_socket_server_exports, {
   IPCSocketServer: () => IPCSocketServer
 });
 module.exports = __toCommonJS(ipc_socket_server_exports);
-var import_net = __toESM(require("net"));
+var import_crypto = require("crypto");
 var import_fs = __toESM(require("fs"));
+var import_net = __toESM(require("net"));
 var import_path = __toESM(require("path"));
+var import_xpipe = __toESM(require("xpipe"));
 var import_app_supervisor = require("../app-supervisor");
 var import_ipc_socket_client = require("./ipc-socket-client");
-var import_crypto = require("crypto");
 const _IPCSocketServer = class _IPCSocketServer {
   socketServer;
   constructor(server) {
@@ -64,10 +65,10 @@ const _IPCSocketServer = class _IPCSocketServer {
           }
           const reqId = (0, import_crypto.randomUUID)();
           const dataObj = JSON.parse(message);
-          _IPCSocketServer.handleClientMessage({ reqId, ...dataObj }).then(() => {
+          _IPCSocketServer.handleClientMessage({ reqId, ...dataObj }).then((result) => {
             (0, import_ipc_socket_client.writeJSON)(c, {
               reqId,
-              type: "success"
+              type: result === false ? "not_found" : "success"
             });
           }).catch((err) => {
             (0, import_ipc_socket_client.writeJSON)(c, {
@@ -82,25 +83,43 @@ const _IPCSocketServer = class _IPCSocketServer {
         }
       });
     });
-    socketServer.listen(socketPath, () => {
+    socketServer.listen(import_xpipe.default.eq(socketPath), () => {
       console.log(`Gateway IPC Server running at ${socketPath}`);
     });
     return new _IPCSocketServer(socketServer);
   }
   static async handleClientMessage({ reqId, type, payload }) {
-    console.log(`cli received message ${type}`);
+    if (type === "appReady") {
+      const status = await new Promise((resolve, reject) => {
+        let status2;
+        const max = 300;
+        let count = 0;
+        const timer = setInterval(async () => {
+          status2 = import_app_supervisor.AppSupervisor.getInstance().getAppStatus("main");
+          if (status2 === "running") {
+            clearInterval(timer);
+            resolve(status2);
+          }
+          if (count++ > max) {
+            reject("error");
+          }
+        }, 500);
+      });
+      console.log("status", status);
+      return status;
+    }
     if (type === "passCliArgv") {
       const argv = payload.argv;
       const mainApp = await import_app_supervisor.AppSupervisor.getInstance().getApp("main");
       if (!mainApp.cli.hasCommand(argv[2])) {
-        console.log("passCliArgv", argv[2]);
         await mainApp.pm.loadCommands();
       }
       const cli = mainApp.cli;
       if (!cli.parseHandleByIPCServer(argv, {
         from: "node"
       })) {
-        throw new Error("Not handle by ipc server");
+        mainApp.log.debug("Not handle by ipc server");
+        return false;
       }
       return mainApp.runAsCLI(argv, {
         reqId,

package/lib/middlewares/data-wrapping.js

@@ -35,7 +35,7 @@ module.exports = __toCommonJS(data_wrapping_exports);
 var import_stream = __toESM(require("stream"));
 function dataWrapping() {
   return /* @__PURE__ */ __name(async function dataWrapping2(ctx, next) {
-    var _a;
+    var _a, _b;
     await next();
     if (ctx.withoutDataWrapping) {
       return;
@@ -55,27 +55,30 @@ function dataWrapping() {
       ctx.body = {
         data: ctx.body
       };
-      return;
-    }
-    if (ctx.body) {
-      const { rows, ...meta } = ctx.body;
-      if (rows) {
-        ctx.body = {
-          data: rows,
-          meta
-        };
-      } else {
+    } else {
+      if (ctx.body) {
+        const { rows, ...meta } = ctx.body;
+        if (rows) {
+          ctx.body = {
+            data: rows,
+            meta
+          };
+        } else {
+          ctx.body = {
+            data: ctx.body
+          };
+          if (ctx.bodyMeta) {
+            ctx.body.meta = ctx.bodyMeta;
+          }
+        }
+      } else if (ctx.action) {
         ctx.body = {
           data: ctx.body
         };
-        if (ctx.bodyMeta) {
-          ctx.body.meta = ctx.bodyMeta;
-        }
       }
-    } else if (ctx.action) {
-      ctx.body = {
-        data: ctx.body
-      };
+    }
+    if (ctx.body && ((_b = ctx.state.messages) == null ? void 0 : _b.length)) {
+      ctx.body.messages = ctx.state.messages;
     }
   }, "dataWrapping");
 }

package/lib/migrations/20230912193824-package-name-unique.js

@@ -29,13 +29,20 @@ const _package_name_unique_default = class _package_name_unique_default extends
   async up() {
     const tableNameWithSchema = this.pm.collection.getTableNameWithSchema();
     const field = this.pm.collection.getField("packageName");
-    await this.db.sequelize.getQueryInterface().addColumn(tableNameWithSchema, field.columnName(), {
-      type: import_database.DataTypes.STRING
-    });
-    await this.db.sequelize.getQueryInterface().addConstraint(tableNameWithSchema, {
-      type: "unique",
-      fields: [field.columnName()]
-    });
+    const exists = await field.existsInDb();
+    if (exists) {
+      return;
+    }
+    try {
+      await this.db.sequelize.getQueryInterface().addColumn(tableNameWithSchema, field.columnName(), {
+        type: import_database.DataTypes.STRING
+      });
+      await this.db.sequelize.getQueryInterface().addConstraint(tableNameWithSchema, {
+        type: "unique",
+        fields: [field.columnName()]
+      });
+    } catch (error) {
+    }
   }
 };
 __name(_package_name_unique_default, "default");

package/lib/plugin-manager/plugin-manager.d.ts

@@ -5,6 +5,7 @@ import Application from '../application';
 import { Plugin } from '../plugin';
 import { PluginManagerRepository } from './plugin-manager-repository';
 import { PluginData } from './types';
+export declare const sleep: (timeout?: number) => Promise<unknown>;
 export interface PluginManagerOptions {
     app: Application;
     plugins?: any[];
@@ -39,7 +40,9 @@ export declare class PluginManager {
     get(name: string | typeof Plugin): Plugin<any>;
     has(name: string | typeof Plugin): boolean;
     del(name: string | typeof Plugin): void;
-    create(pluginName: string): Promise<void>;
+    create(pluginName: string, options?: {
+        forceRecreate?: boolean;
+    }): Promise<void>;
     add(plugin?: any, options?: any, insert?: boolean, isUpgrade?: boolean): Promise<void>;
     initPlugins(): Promise<void>;
     loadCommands(): Promise<void>;
@@ -47,7 +50,10 @@ export declare class PluginManager {
     install(options?: InstallOptions): Promise<void>;
     enable(name: string | string[]): Promise<void>;
     disable(name: string | string[]): Promise<void>;
-    remove(name: string | string[]): Promise<void>;
+    remove(name: string | string[], options?: {
+        removeDir?: boolean;
+        force?: boolean;
+    }): Promise<void>;
     loadOne(plugin: Plugin): Promise<void>;
     addViaCLI(urlOrName: string, options?: PluginData): Promise<void>;
     addByNpm(options: {

package/lib/plugin-manager/plugin-manager.js

@@ -30,7 +30,8 @@ var plugin_manager_exports = {};
 __export(plugin_manager_exports, {
   AddPresetError: () => AddPresetError,
   PluginManager: () => PluginManager,
-  default: () => plugin_manager_default
+  default: () => plugin_manager_default,
+  sleep: () => sleep
 });
 module.exports = __toCommonJS(plugin_manager_exports);
 var import_utils = require("@nocobase/utils");
@@ -46,6 +47,11 @@ var import_collection = __toESM(require("./options/collection"));
 var import_resource = __toESM(require("./options/resource"));
 var import_plugin_manager_repository = require("./plugin-manager-repository");
 var import_utils2 = require("./utils");
+const sleep = /* @__PURE__ */ __name(async (timeout = 0) => {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, timeout);
+  });
+}, "sleep");
 const _AddPresetError = class _AddPresetError extends Error {
 };
 __name(_AddPresetError, "AddPresetError");
@@ -177,12 +183,15 @@ const _PluginManager = class _PluginManager {
       this.app.pm.pluginInstances.delete(instance.constructor);
     }
   }
-  async create(pluginName) {
-    console.log("creating...");
+  async create(pluginName, options) {
     const createPlugin = /* @__PURE__ */ __name(async (name) => {
+      const pluginDir = (0, import_path.resolve)(process.cwd(), "packages/plugins", name);
+      if (options == null ? void 0 : options.forceRecreate) {
+        await import_fs.default.promises.rm(pluginDir, { recursive: true, force: true });
+      }
       const { PluginGenerator } = require("@nocobase/cli/src/plugin-generator");
       const generator = new PluginGenerator({
-        cwd: (0, import_path.resolve)(process.cwd(), name),
+        cwd: process.cwd(),
         args: {},
         context: {
           name
@@ -191,13 +200,38 @@ const _PluginManager = class _PluginManager {
       await generator.run();
     }, "createPlugin");
     await createPlugin(pluginName);
-    await this.repository.create({
+    try {
+      await this.app.db.auth({ retry: 1 });
+      const installed = await this.app.isInstalled();
+      if (!installed) {
+        console.log(`yarn pm add ${pluginName}`);
+        return;
+      }
+    } catch (error) {
+      return;
+    }
+    this.app.log.info("attempt to add the plugin to the app");
+    let packageName;
+    try {
+      packageName = await _PluginManager.getPackageName(pluginName);
+    } catch (error) {
+      packageName = pluginName;
+    }
+    const json = await _PluginManager.getPackageJson(packageName);
+    this.app.log.info(`add plugin [${packageName}]`, {
+      name: pluginName,
+      packageName,
+      version: json.version
+    });
+    await this.repository.updateOrCreate({
       values: {
         name: pluginName,
-        packageName: pluginName,
-        version: "0.1.0"
-      }
+        packageName,
+        version: json.version
+      },
+      filterKeys: ["name"]
     });
+    await sleep(1e3);
     await (0, import_helper.tsxRerunning)();
   }
   async add(plugin, options = {}, insert = false, isUpgrade = false) {
@@ -254,7 +288,7 @@ const _PluginManager = class _PluginManager {
     await this.initOtherPlugins();
   }
   async loadCommands() {
-    this.app.log.info("load commands");
+    this.app.log.debug("load commands");
     const items = await this.repository.find({
       filter: {
         enabled: true
@@ -486,37 +520,70 @@ const _PluginManager = class _PluginManager {
       throw error;
     }
   }
-  async remove(name) {
+  async remove(name, options) {
     const pluginNames = import_lodash.default.castArray(name);
-    for (const pluginName of pluginNames) {
-      const plugin = this.get(pluginName);
-      if (!plugin) {
-        continue;
-      }
-      if (plugin.enabled) {
-        throw new Error(`${pluginName} plugin is enabled`);
+    const records = pluginNames.map((name2) => {
+      return {
+        name: name2,
+        packageName: name2
+      };
+    });
+    const removeDir = /* @__PURE__ */ __name(async () => {
+      await Promise.all(
+        records.map(async (plugin) => {
+          const dir = (0, import_path.resolve)(process.env.NODE_MODULES_PATH, plugin.packageName);
+          try {
+            const realDir = await import_fs.default.promises.realpath(dir);
+            this.app.log.debug(`rm -rf ${realDir}`);
+            return import_fs.default.promises.rm(realDir, { force: true, recursive: true });
+          } catch (error) {
+            return false;
+          }
+        })
+      );
+      await (0, import_execa.default)("yarn", ["nocobase", "postinstall"]);
+    }, "removeDir");
+    if (options == null ? void 0 : options.force) {
+      await this.repository.destroy({
+        filter: {
+          name: pluginNames
+        }
+      });
+    } else {
+      await this.app.load();
+      for (const pluginName of pluginNames) {
+        const plugin = this.get(pluginName);
+        if (!plugin) {
+          continue;
+        }
+        if (plugin.enabled) {
+          throw new Error(`plugin is enabled [${pluginName}]`);
+        }
+        await plugin.beforeRemove();
       }
-      await plugin.beforeRemove();
-    }
-    await this.repository.destroy({
-      filter: {
-        name: pluginNames
+      await this.repository.destroy({
+        filter: {
+          name: pluginNames
+        }
+      });
+      const plugins = [];
+      for (const pluginName of pluginNames) {
+        const plugin = this.get(pluginName);
+        if (!plugin) {
+          continue;
+        }
+        plugins.push(plugin);
+        this.del(pluginName);
+        await plugin.afterRemove();
       }
-    });
-    const plugins = [];
-    for (const pluginName of pluginNames) {
-      const plugin = this.get(pluginName);
-      if (!plugin) {
-        continue;
+      if (await this.app.isStarted()) {
+        await this.app.tryReloadOrRestart();
       }
-      plugins.push(plugin);
-      this.del(pluginName);
     }
-    await this.app.reload();
-    for (const plugin of plugins) {
-      await plugin.afterRemove();
+    if (options == null ? void 0 : options.removeDir) {
+      await removeDir();
     }
-    await this.app.emitStartedEvent();
+    await (0, import_execa.default)("yarn", ["nocobase", "refresh"]);
   }
   async loadOne(plugin) {
     this.app.setMaintainingMessage(`loading plugin ${plugin.name}...`);
@@ -572,6 +639,7 @@ const _PluginManager = class _PluginManager {
       await this.add(opts["name"] || urlOrName, opts, true);
     }
     await this.app.emitStartedEvent();
+    await (0, import_execa.default)("yarn", ["nocobase", "postinstall"]);
   }
   async addByNpm(options) {
     let { name = "", registry, packageName, authToken } = options;
@@ -823,5 +891,6 @@ var plugin_manager_default = PluginManager;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AddPresetError,
-  PluginManager
+  PluginManager,
+  sleep
 });

package/lib/plugin.d.ts

@@ -37,7 +37,8 @@ export declare abstract class Plugin<O = any> implements PluginInterface {
     setOptions(options: any): void;
     getName(): any;
     createLogger(options: LoggerOptions): import("winston").Logger;
-    get _sourceDir(): "src" | "dist" | "lib";
+    protected _sourceDir: string;
+    protected getSourceDir(): Promise<string>;
     loadCommands(): Promise<void>;
     loadMigrations(): Promise<{
         beforeLoad: any[];
@@ -59,6 +60,7 @@ export declare abstract class Plugin<O = any> implements PluginInterface {
     loadCollections(): Promise<void>;
     requiredPlugins(): any[];
     t(text: TFuncKey | TFuncKey[], options?: TOptions): import("i18next").TFunctionDetailedResult<object>;
+    protected isDev(): Promise<boolean>;
     toJSON(options?: any): Promise<any>;
 }
 export default Plugin;

package/lib/plugin.js

@@ -86,18 +86,25 @@ const _Plugin = class _Plugin {
   createLogger(options) {
     return this.app.createLogger(options);
   }
-  get _sourceDir() {
+  _sourceDir;
+  async getSourceDir() {
+    if (this._sourceDir) {
+      return this._sourceDir;
+    }
+    if (await this.isDev()) {
+      return this._sourceDir = "src";
+    }
     if ((0, import_path.basename)(__dirname) === "src") {
-      return "src";
+      return this._sourceDir = "src";
     }
-    return this.isPreset ? "lib" : "dist";
+    return this._sourceDir = this.isPreset ? "lib" : "dist";
   }
   async loadCommands() {
     const extensions = ["js", "ts"];
     const directory = (0, import_path.resolve)(
       process.env.NODE_MODULES_PATH,
       this.options.packageName,
-      this._sourceDir,
+      await this.getSourceDir(),
       "server/commands"
     );
     const patten = `${directory}/*.{${extensions.join(",")}}`;
@@ -122,7 +129,7 @@ const _Plugin = class _Plugin {
     const directory = (0, import_path.resolve)(
       process.env.NODE_MODULES_PATH,
       this.options.packageName,
-      this._sourceDir,
+      await this.getSourceDir(),
       "server/migrations"
     );
     return await this.app.loadMigrations({
@@ -164,7 +171,7 @@ const _Plugin = class _Plugin {
     const directory = (0, import_path.resolve)(
       process.env.NODE_MODULES_PATH,
       this.options.packageName,
-      this._sourceDir,
+      await this.getSourceDir(),
       "server/collections"
     );
     if (await (0, import_utils.fsExists)(directory)) {
@@ -180,6 +187,18 @@ const _Plugin = class _Plugin {
   t(text, options = {}) {
     return this.app.i18n.t(text, { ns: this.options["packageName"], ...options });
   }
+  async isDev() {
+    if (!this.options.packageName) {
+      return false;
+    }
+    const file = await import_fs.default.promises.realpath(
+      (0, import_path.resolve)(process.env.NODE_MODULES_PATH || (0, import_path.resolve)(process.cwd(), "node_modules"), this.options.packageName)
+    );
+    if (file.startsWith((0, import_path.resolve)(process.cwd(), "packages"))) {
+      return !!process.env.IS_DEV_CMD;
+    }
+    return false;
+  }
   async toJSON(options = {}) {
     const { locale = "en-US" } = options;
     const { name, packageName, packageJson } = this.options;
@@ -190,10 +209,12 @@ const _Plugin = class _Plugin {
     }
     const results = {
       ...this.options,
+      keywords: packageJson.keywords,
       readmeUrl: (0, import_plugin_manager.getExposeReadmeUrl)(packageName, locale),
       changelogUrl: (0, import_plugin_manager.getExposeChangelogUrl)(packageName),
       displayName: packageJson[`displayName.${locale}`] || packageJson.displayName || name,
-      description: packageJson[`description.${locale}`] || packageJson.description
+      description: packageJson[`description.${locale}`] || packageJson.description,
+      homepage: packageJson[`homepage.${locale}`] || packageJson.homepage
     };
     if (!options.withOutOpenFile) {
       const file = await import_fs.default.promises.realpath(

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nocobase/server",
-    "version": "0.19.0-alpha.1",
+    "version": "0.19.0-alpha.10",
     "main": "lib/index.js",
     "types": "./lib/index.d.ts",
     "license": "Apache-2.0",
@@ -10,17 +10,17 @@
         "@koa/cors": "^3.1.0",
         "@koa/multer": "^3.0.2",
         "@koa/router": "^9.4.0",
-        "@nocobase/acl": "0.19.0-alpha.1",
-        "@nocobase/actions": "0.19.0-alpha.1",
-        "@nocobase/auth": "0.19.0-alpha.1",
-        "@nocobase/cache": "0.19.0-alpha.1",
-        "@nocobase/database": "0.19.0-alpha.1",
-        "@nocobase/evaluators": "0.19.0-alpha.1",
-        "@nocobase/logger": "0.19.0-alpha.1",
-        "@nocobase/resourcer": "0.19.0-alpha.1",
-        "@nocobase/sdk": "0.19.0-alpha.1",
-        "@nocobase/telemetry": "0.19.0-alpha.1",
-        "@nocobase/utils": "0.19.0-alpha.1",
+        "@nocobase/acl": "0.19.0-alpha.10",
+        "@nocobase/actions": "0.19.0-alpha.10",
+        "@nocobase/auth": "0.19.0-alpha.10",
+        "@nocobase/cache": "0.19.0-alpha.10",
+        "@nocobase/database": "0.19.0-alpha.10",
+        "@nocobase/evaluators": "0.19.0-alpha.10",
+        "@nocobase/logger": "0.19.0-alpha.10",
+        "@nocobase/resourcer": "0.19.0-alpha.10",
+        "@nocobase/sdk": "0.19.0-alpha.10",
+        "@nocobase/telemetry": "0.19.0-alpha.10",
+        "@nocobase/utils": "0.19.0-alpha.10",
         "@types/decompress": "4.2.4",
         "@types/ini": "^1.3.31",
         "@types/koa-send": "^4.1.3",
@@ -53,5 +53,5 @@
         "@types/serve-handler": "^6.1.1",
         "@types/ws": "^8.5.5"
     },
-    "gitHead": "64601944412fc4d2e2bd05f4b982118dd28247dc"
+    "gitHead": "d09d81eba67339da36bcec27939a85b35d180770"
 }