rewrite

src/entry.ts

+import { Logger } from 'koishi';
 import { installPluginEntry } from './install-plugin';
 import { prodEntry } from './prod';
 
 const choice = process.argv[2];
 
+const logger = new Logger('bootstrap');
+
 switch (choice) {
   case 'install':
     installPluginEntry();
@@ -11,6 +14,6 @@ switch (choice) {
     prodEntry();
     break;
   default:
-    console.log(`Unknown command '${choice}'.`);
+    logger.error(`Unknown command '${choice}'.`);
     process.exit(1);
 }

src/install-plugin.ts

-import yaml from 'yaml';
 import fs from 'fs';
-import { KoishiConfig, PackageConfig } from './def/interfaces';
 import { Logger } from 'koishi';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import loadJsonFile from 'load-json-file';
 import path from 'path';
 import { getPackageJsonPackages } from './utils/read-package-json';
+import { loadConfig } from './utils/load-config';
 const execAsync = promisify(exec);
 
-const logger = new Logger('bootstrap');
-
-async function loadFromYaml(): Promise<KoishiConfig> {
-  return yaml.parse(await fs.promises.readFile('./koishi.config.yml', 'utf-8'));
-}
-
-function loadFromJs(): KoishiConfig {
-  return require('./koishi.config.js');
-}
-
-async function loadConfig(): Promise<KoishiConfig | undefined> {
-  try {
-    logger.info(`Reading config from ./koishi.config.yml.`);
-    return await loadFromYaml();
-  } catch (e) {
-    logger.warn(
-      `Failed reading from YAML: ${(e as any).toString()} , trying JS.`,
-    );
-    logger.info(`Reading config from ./koishi.config.js.`);
-    try {
-      return loadFromJs();
-    } catch (e) {
-      logger.warn(`Failed reading from JS: ${(e as any).toString()} .`);
-      return;
-    }
-  }
-}
+const logger = new Logger('bootstrap-install-plugin');
 
 async function checkPluginExists(
   name: string,

src/prod.ts

 import path from 'path';
-import { getPackageJsonPackages } from './utils/read-package-json';
 import fs from 'fs';
+import { loadConfig } from './utils/load-config';
+import { Logger } from 'koishi';
 
-async function handlePackageEntry(packageName: string, versionString: string) {
-  if (!versionString.startsWith('file:')) {
-    return;
-  }
-  console.log(`Cleaning package ${packageName}...`);
-  const packagePath = versionString.slice(5);
+const logger = new Logger('bootstrap-prod');
+
+async function handlePackageEntry(packagePath: string) {
   const packagesToRemove = ['koishi', '@koishijs/core', '@koishijs/utils'].map(
     (p) => path.join(packagePath, 'node_modules', p),
   );
@@ -15,7 +13,7 @@ async function handlePackageEntry(packageName: string, versionString: string) {
     packagesToRemove.map(async (path) => {
       try {
         await fs.promises.access(path);
-        console.log(`Removing ${path} ...`);
+        logger.info(`Removing ${path} ...`);
         await fs.promises.rm(path, { recursive: true });
       } catch (e) {}
     }),
@@ -23,11 +21,16 @@ async function handlePackageEntry(packageName: string, versionString: string) {
 }
 
 export async function prodEntry() {
-  console.log(`Running production preparations...`);
-  const deps = await getPackageJsonPackages();
-  const entries = Object.entries(deps);
-  await Promise.all(
-    entries.map((entry) => handlePackageEntry(entry[0], entry[1])),
+  logger.info(`Running production preparations...`);
+  const config = await loadConfig();
+  const plugins = config?.plugins;
+  if (!plugins) {
+    logger.warn(`No plugins found, exiting.`);
+    return;
+  }
+  const pluginList = Object.keys(plugins).filter((name) =>
+    name.startsWith('./'),
   );
-  console.log(`Done.`);
+  await Promise.all(pluginList.map((name) => handlePackageEntry(name)));
+  logger.info(`Done.`);
 }

src/utils/load-config.ts

+import { KoishiConfig } from '../def/interfaces';
+import yaml from 'yaml';
+import fs from 'fs';
+import path from 'path';
+import loadJsonFile from 'load-json-file';
+import { Logger } from 'koishi';
+
+const logger = new Logger('bootstrap-config-loader');
+
+async function loadFromYaml(): Promise<KoishiConfig> {
+  return yaml.parse(await fs.promises.readFile('./koishi.config.yml', 'utf-8'));
+}
+
+function loadFromJs(): KoishiConfig {
+  return require(path.join(process.cwd(), 'koishi.config.js'));
+}
+
+async function loadFromJson(): Promise<KoishiConfig> {
+  return await loadJsonFile('./koishi.config.json');
+}
+
+export async function loadConfig(): Promise<KoishiConfig | undefined> {
+  try {
+    logger.info(`Reading config from ./koishi.config.yml.`);
+    return await loadFromYaml();
+  } catch (e) {
+    logger.warn(
+      `Failed reading from YAML: ${(e as any).toString()} , trying JS.`,
+    );
+    logger.info(`Reading config from ./koishi.config.js.`);
+    try {
+      return loadFromJs();
+    } catch (e) {
+      logger.warn(
+        `Failed reading from JS: ${(e as any).toString()} , trying JSON.`,
+      );
+      logger.info(`Reading config from ./koishi.config.json.`);
+      try {
+        return await loadFromJson();
+      } catch (e) {
+        logger.warn(
+          `Failed reading from JSON: ${(e as any).toString()} , exiting.`,
+        );
+        return;
+      }
+    }
+  }
+}