@powerhousedao/connect 1.0.0-dev.196 → 1.0.0-dev.198

package/dist/studio/index.js

@@ -1,14 +1,14 @@
 // studio/index.ts
 import { Command } from "commander";
-import fs4 from "node:fs";
-import { dirname, isAbsolute, join as join3, resolve } from "node:path";
+import fs5 from "node:fs";
+import { dirname as dirname3, isAbsolute, join as join5, resolve } from "node:path";
 
 // studio/server.ts
 import basicSsl from "@vitejs/plugin-basic-ssl";
-import { exec } from "node:child_process";
-import fs3 from "node:fs";
-import { join as join2 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { exec as exec2 } from "node:child_process";
+import fs4 from "node:fs";
+import { join as join4 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { createLogger, createServer } from "vite";
 import { viteEnvs } from "vite-envs";
 
@@ -50,14 +50,19 @@ function removeBase64EnvValues() {
   });
 }
 
-// studio/vite-plugin.ts
-import fs2 from "node:fs";
+// studio/vite-plugins/base.ts
+import MagicString from "magic-string";
 import path from "node:path";
-import {
-  normalizePath
-} from "vite";
+import { normalizePath } from "vite";
+var externalIds = /^react(-dom)?(\/.*)?$/;
 var LOCAL_DOCUMENT_MODELS_IMPORT = "LOCAL_DOCUMENT_MODELS";
 var LOCAL_DOCUMENT_EDITORS_IMPORT = "LOCAL_DOCUMENT_EDITORS";
+var HMR_MODULE_IMPORT = "PH:HMR_MODULE";
+var STUDIO_IMPORTS = [
+  LOCAL_DOCUMENT_MODELS_IMPORT,
+  LOCAL_DOCUMENT_EDITORS_IMPORT,
+  HMR_MODULE_IMPORT
+];
 function getStudioConfig(env) {
   const config = {};
   const LOCAL_DOCUMENT_MODELS = process.env.LOCAL_DOCUMENT_MODELS ?? env?.LOCAL_DOCUMENT_MODELS;
@@ -74,8 +79,233 @@ function getStudioConfig(env) {
       LOCAL_DOCUMENT_EDITORS_PATH
     );
   }
+  if (typeof process.env.LOAD_EXTERNAL_PACKAGES !== "undefined") {
+    config.LOAD_EXTERNAL_PACKAGES = process.env.LOAD_EXTERNAL_PACKAGES;
+  }
   return config;
 }
+function viteIgnoreStaticImport(_importKeys) {
+  const importKeys = _importKeys.filter(
+    (key) => typeof key === "string" || key instanceof RegExp
+  );
+  return {
+    name: "vite-plugin-ignore-static-import",
+    enforce: "pre",
+    // vite will still append /@id/ to an external import
+    // so this will rewrite the 'vite:import-analysis' prefix
+    configResolved(resolvedConfig) {
+      const values = importKeys.map(
+        (key) => typeof key === "string" ? key : key.source
+      );
+      const reg = new RegExp(
+        `("|')\\/@id\\/(${values.join("|")})(\\/[^"'\\\\]*)?\\1`,
+        "g"
+      );
+      resolvedConfig.plugins.push({
+        name: "vite-plugin-ignore-static-import-replace-idprefix",
+        transform: (code) => {
+          const s = new MagicString(code);
+          const matches = code.matchAll(reg);
+          let modified = false;
+          for (const match of matches) {
+            s.overwrite(
+              match.index,
+              match.index + match[0].length,
+              match[0].replace("/@id/", "")
+            );
+            modified = true;
+          }
+          if (!modified) return null;
+          return {
+            code: s.toString(),
+            map: s.generateMap({ hires: true })
+            // Generate an accurate source map
+          };
+        }
+      });
+    },
+    // prevents the external import from being transformed to 'node_modules/...'
+    resolveId: (id) => {
+      if (importKeys.some(
+        (key) => typeof key === "string" ? key === id : key.test(id)
+      )) {
+        return { id, external: true };
+      }
+    },
+    // returns empty string to prevent "Pre-transform error: Failed to load url"
+    load(id) {
+      if (importKeys.some(
+        (key) => typeof key === "string" ? key === id : key.test(id)
+      )) {
+        return "";
+      }
+    }
+  };
+}
+function viteReplaceImports(imports) {
+  const importKeys = Object.keys(imports);
+  return {
+    name: "vite-plugin-connect-replace-imports",
+    enforce: "pre",
+    config(config) {
+      const resolve2 = config.resolve ?? {};
+      const alias = resolve2.alias;
+      let resolvedAlias;
+      if (Array.isArray(alias)) {
+        const arrayAlias = [...alias];
+        arrayAlias.push(
+          ...Object.entries(imports).map(([find, replacement]) => ({
+            find,
+            replacement
+          }))
+        );
+        resolvedAlias = arrayAlias;
+      } else if (typeof alias === "object") {
+        resolvedAlias = {
+          ...alias,
+          ...imports
+        };
+      } else if (typeof alias === "undefined") {
+        resolvedAlias = { ...imports };
+      } else {
+        console.error("resolve.alias was not recognized");
+      }
+      if (resolvedAlias) {
+        resolve2.alias = resolvedAlias;
+        config.resolve = resolve2;
+      }
+    },
+    resolveId: (id) => {
+      if (importKeys.includes(id)) {
+        return {
+          id,
+          external: true
+        };
+      }
+    }
+  };
+}
+
+// studio/vite-plugins/external-packages.ts
+import { getConfig } from "@powerhousedao/config/powerhouse";
+import fs2 from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { normalizePath as normalizePath2 } from "vite";
+var __dirname = join2(process.cwd(), ".ph/");
+var EXTERNAL_PACKAGES_IMPORT = "PH:EXTERNAL_PACKAGES";
+var IMPORT_SCRIPT_FILE = normalizePath2(
+  join2(__dirname, "external-packages.js")
+);
+function generateImportScript(packages) {
+  const targetDir = dirname(IMPORT_SCRIPT_FILE);
+  if (!fs2.existsSync(targetDir)) {
+    fs2.mkdirSync(targetDir, { recursive: true });
+  }
+  const imports = [];
+  const moduleNames = [];
+  let counter = 0;
+  for (const packageName of packages) {
+    const moduleName = `module${counter}`;
+    moduleNames.push(moduleName);
+    imports.push(`import * as ${moduleName} from '${packageName}';`);
+    counter++;
+  }
+  const exportStatement = `export default [${moduleNames.join(", ")}];`;
+  const fileContent = `${imports.join("\n")}
+
+${exportStatement}`;
+  fs2.writeFileSync(IMPORT_SCRIPT_FILE, fileContent);
+  return IMPORT_SCRIPT_FILE;
+}
+var viteLoadExternalPackages = (packages, hmr = false) => {
+  if (!packages?.length && !hmr) {
+    return viteIgnoreStaticImport([EXTERNAL_PACKAGES_IMPORT]);
+  }
+  generateImportScript(packages ?? []);
+  process.env.LOAD_EXTERNAL_PACKAGES = "true";
+  return [
+    viteReplaceImports({ [EXTERNAL_PACKAGES_IMPORT]: IMPORT_SCRIPT_FILE }),
+    hmr && {
+      name: "vite-plugin-studio-external-packages",
+      handleHotUpdate({ file, server, modules }) {
+        if (file.endsWith("powerhouse.config.json")) {
+          console.log("External packages file changed, reloading...");
+          const config = getConfig();
+          generateImportScript(
+            config.packages?.map((p) => p.packageName) ?? []
+          );
+          const module = server.moduleGraph.getModuleById(IMPORT_SCRIPT_FILE);
+          if (module) {
+            server.moduleGraph.invalidateModule(module);
+            return [module].concat(...module.importers.values());
+          }
+        } else if (file === IMPORT_SCRIPT_FILE) {
+          modules.filter((module) => module.id === IMPORT_SCRIPT_FILE).forEach((module) => {
+            server.ws.send("studio:external-packages-updated", {
+              url: module.url,
+              timestamp: module.lastHMRTimestamp
+            });
+          });
+          return modules;
+        }
+        return modules;
+      }
+    }
+  ];
+};
+
+// studio/vite-plugins/studio.ts
+import fs3 from "node:fs";
+
+// studio/vite-plugins/hmr.ts
+import { exec } from "node:child_process";
+import { dirname as dirname2, join as join3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { normalizePath as normalizePath3 } from "vite";
+var __dirname2 = import.meta.dirname || dirname2(fileURLToPath2(import.meta.url));
+var viteLoadHMRModule = () => {
+  return [
+    viteReplaceImports({
+      [HMR_MODULE_IMPORT]: normalizePath3(join3(__dirname2, "hmr.js"))
+    }),
+    {
+      name: "vite-plugin-studio-hmr-module",
+      configureServer(server) {
+        handleExternalPackageEvents(server);
+      }
+    }
+  ];
+};
+var handleExternalPackageEvents = (server) => {
+  server.ws.on("studio:add-external-package", (data, client) => {
+    const { name } = data;
+    const installProcess = exec(
+      `ph install ${name}`,
+      {
+        cwd: process.cwd()
+      },
+      (error) => {
+        if (error) {
+          console.error(`	[${name}]: ${error.message}`);
+        } else {
+          server.ws.send("studio:external-package-added", {
+            name
+          });
+        }
+      }
+    );
+    installProcess.stdout?.on("data", (data2) => {
+      console.log(`	[${name}]: ${data2.toString().trim()}`);
+    });
+    console.log("Installing external package:", name);
+  });
+  server.ws.on("studio:remove-external-package", (data, client) => {
+    const { name } = data;
+    console.log("Removing external package", name);
+  });
+};
+
+// studio/vite-plugins/studio.ts
 function watchLocalFiles(server, documentModelsPath, editorsPath) {
   const debounce = (callback, delay = 100) => {
     let timeout;
@@ -105,7 +335,7 @@ function watchLocalFiles(server, documentModelsPath, editorsPath) {
       `Watching local document models at '${documentModelsPath}'...`
     );
     try {
-      fs2.watch(
+      fs3.watch(
         documentModelsPath,
         {
           recursive: true
@@ -121,7 +351,7 @@ function watchLocalFiles(server, documentModelsPath, editorsPath) {
   if (editorsPath) {
     console.log(`Watching local document editors at '${editorsPath}'...`);
     try {
-      fs2.watch(
+      fs3.watch(
         editorsPath,
         {
           recursive: true
@@ -135,58 +365,8 @@ function watchLocalFiles(server, documentModelsPath, editorsPath) {
     }
   }
 }
-function viteIgnoreStaticImport(importKeys) {
-  return {
-    name: "vite-plugin-ignore-static-import",
-    enforce: "pre",
-    // vite will still append /@id/ to an external import
-    // so this will rewrite the 'vite:import-analysis' prefix
-    configResolved(resolvedConfig) {
-      const values = importKeys.map(
-        (key) => typeof key === "string" ? key : key.source
-      );
-      const reg = new RegExp(
-        `("|')\\/@id\\/(${values.join("|")})(\\/[^"'\\\\]*)?\\1`,
-        "g"
-      );
-      resolvedConfig.plugins.push({
-        name: "vite-plugin-ignore-static-import-replace-idprefix",
-        transform: (code) => {
-          const matches = code.matchAll(reg);
-          for (const match of matches) {
-            code = code.replaceAll(
-              match[0],
-              match[0].replace("/@id/", "")
-            );
-          }
-          return code;
-        }
-      });
-    },
-    // prevents the external import from being transformed to 'node_modules/...'
-    resolveId: (id) => {
-      if (importKeys.some(
-        (key) => typeof key === "string" ? key === id : key.test(id)
-      )) {
-        return { id, external: true };
-      }
-    },
-    // returns empty string to prevent "Pre-transform error: Failed to load url"
-    load(id) {
-      if (importKeys.some(
-        (key) => typeof key === "string" ? key === id : key.test(id)
-      )) {
-        return "";
-      }
-    }
-  };
-}
 function viteConnectDevStudioPlugin(enabled = false, env) {
   const studioConfig = getStudioConfig(env);
-  const importKeys = [
-    LOCAL_DOCUMENT_MODELS_IMPORT,
-    LOCAL_DOCUMENT_EDITORS_IMPORT
-  ];
   const localDocumentModelsPath = studioConfig[LOCAL_DOCUMENT_MODELS_IMPORT];
   const localDocumentEditorsPath = studioConfig[LOCAL_DOCUMENT_EDITORS_IMPORT];
   return [
@@ -196,42 +376,36 @@ function viteConnectDevStudioPlugin(enabled = false, env) {
       "@powerhousedao/scalars",
       "@powerhousedao/design-system"
     ]),
+    localDocumentModelsPath ? viteReplaceImports({
+      [LOCAL_DOCUMENT_MODELS_IMPORT]: localDocumentModelsPath
+    }) : viteIgnoreStaticImport([LOCAL_DOCUMENT_MODELS_IMPORT]),
+    localDocumentEditorsPath ? viteReplaceImports({
+      [LOCAL_DOCUMENT_EDITORS_IMPORT]: localDocumentEditorsPath
+    }) : viteIgnoreStaticImport([LOCAL_DOCUMENT_EDITORS_IMPORT]),
+    enabled ? viteLoadHMRModule() : viteIgnoreStaticImport([HMR_MODULE_IMPORT]),
     {
       name: "vite-plugin-connect-dev-studio",
       enforce: "pre",
       config(config) {
-        if (!localDocumentModelsPath && !localDocumentEditorsPath) {
-          return;
+        if (!config.build) {
+          config.build = {};
         }
-        const resolve2 = config.resolve ?? {};
-        const alias = resolve2.alias;
-        let resolvedAlias;
-        if (Array.isArray(alias)) {
-          const arrayAlias = [...alias];
-          if (localDocumentModelsPath) {
-            arrayAlias.push({
-              find: LOCAL_DOCUMENT_MODELS_IMPORT,
-              replacement: localDocumentModelsPath
-            });
-          }
-          if (localDocumentEditorsPath) {
-            arrayAlias.push({
-              find: LOCAL_DOCUMENT_EDITORS_IMPORT,
-              replacement: localDocumentEditorsPath
-            });
-          }
-          resolvedAlias = arrayAlias;
-        } else if (typeof alias === "object") {
-          resolvedAlias = { ...alias, ...studioConfig };
-        } else if (typeof alias === "undefined") {
-          resolvedAlias = { ...studioConfig };
-        } else {
-          console.error("resolve.alias was not recognized");
+        if (!config.build.rollupOptions) {
+          config.build.rollupOptions = {};
         }
-        if (resolvedAlias) {
-          resolve2.alias = resolvedAlias;
-          config.resolve = resolve2;
+        if (!Array.isArray(config.build.rollupOptions.external)) {
+          config.build.rollupOptions.external = [];
         }
+        const buildStudioExternals = enabled ? [
+          externalIds,
+          ...STUDIO_IMPORTS,
+          "@powerhousedao/studio",
+          "@powerhousedao/design-system",
+          "document-model-libs"
+        ] : [externalIds, ...STUDIO_IMPORTS];
+        config.build.rollupOptions.external.push(
+          ...buildStudioExternals
+        );
       },
       configureServer(server) {
         watchLocalFiles(
@@ -239,73 +413,15 @@ function viteConnectDevStudioPlugin(enabled = false, env) {
           localDocumentModelsPath,
           localDocumentEditorsPath
         );
-      },
-      resolveId: (id) => {
-        if (importKeys.includes(id)) {
-          return {
-            id,
-            external: true
-          };
-        }
       }
     }
   ];
 }
-var viteLoadExternalProjects = (enabled = false, _projectsImportPath) => {
-  const moduleName = "EXTERNAL_PROJECTS";
-  const importKeys = [moduleName];
-  const projectsImportPath = normalizePath(_projectsImportPath || "");
-  return [
-    {
-      name: "vite-load-projects",
-      enforce: "pre",
-      config(config) {
-        if (!enabled) return;
-        if (!projectsImportPath || projectsImportPath === "") {
-          return;
-        }
-        const resolve2 = config.resolve ?? {};
-        const alias = resolve2.alias;
-        let resolvedAlias;
-        if (Array.isArray(alias)) {
-          const arrayAlias = [...alias];
-          arrayAlias.push({
-            find: moduleName,
-            replacement: projectsImportPath
-          });
-          resolvedAlias = arrayAlias;
-        } else if (typeof alias === "object") {
-          resolvedAlias = {
-            ...alias,
-            [moduleName]: projectsImportPath
-          };
-        } else if (typeof alias === "undefined") {
-          resolvedAlias = { [moduleName]: projectsImportPath };
-        } else {
-          console.error("resolve.alias was not recognized");
-        }
-        if (resolvedAlias) {
-          resolve2.alias = resolvedAlias;
-          config.resolve = resolve2;
-        }
-        console.log("resolvedAlias", config.resolve?.alias);
-      },
-      resolveId: (id) => {
-        if (importKeys.includes(id)) {
-          return {
-            id,
-            external: true
-          };
-        }
-      }
-    }
-  ];
-};
 
 // studio/server.ts
-var studioDirname2 = fileURLToPath2(new URL(".", import.meta.url));
-var appPath2 = join2(studioDirname2, "..");
-var viteEnvsScript = join2(appPath2, "vite-envs.sh");
+var studioDirname2 = fileURLToPath3(new URL(".", import.meta.url));
+var appPath2 = join4(studioDirname2, "..");
+var viteEnvsScript = join4(appPath2, "vite-envs.sh");
 var projectRoot = process.cwd();
 var logger = createLogger();
 var loggerWarn = logger.warn;
@@ -331,8 +447,8 @@ function runShellScriptPlugin(scriptPath) {
   return {
     name: "vite-plugin-run-shell-script",
     buildStart() {
-      if (fs3.existsSync(scriptPath)) {
-        exec(`sh ${scriptPath}`, (error, stdout, stderr) => {
+      if (fs4.existsSync(scriptPath)) {
+        exec2(`sh ${scriptPath}`, (error, stdout, stderr) => {
           if (error) {
             console.error(
               `Error executing the script: ${error.message}`
@@ -349,15 +465,14 @@ function runShellScriptPlugin(scriptPath) {
   };
 }
 async function startServer(options = {}) {
-  const { enableExternalProjects = true } = options;
   ensureNodeVersion();
   backupIndexHtml(true);
   const PORT = process.env.PORT ? parseInt(process.env.PORT) : 3e3;
   const HOST = process.env.HOST ? process.env.HOST : "0.0.0.0";
   const OPEN_BROWSER = typeof process.env.OPEN_BROWSER === "string" ? process.env.OPEN_BROWSER === "true" : false;
   const studioConfig = getStudioConfig();
-  if (!fs3.existsSync(join2(appPath2, "src"))) {
-    fs3.mkdirSync(join2(appPath2, "src"));
+  if (!fs4.existsSync(join4(appPath2, "src"))) {
+    fs4.mkdirSync(join4(appPath2, "src"));
   }
   process.env.PH_CONNECT_STUDIO_MODE = "true";
   const config = {
@@ -373,7 +488,7 @@ async function startServer(options = {}) {
       alias: {
         jszip: "jszip/dist/jszip.min.js",
         // Resolve to the node_modules in the project root
-        "@powerhousedao/design-system/scalars": join2(
+        "@powerhousedao/design-system/scalars": join4(
           projectRoot,
           "node_modules",
           "@powerhousedao",
@@ -381,35 +496,32 @@ async function startServer(options = {}) {
           "dist",
           "scalars"
         ),
-        "@powerhousedao/design-system": join2(
+        "@powerhousedao/design-system": join4(
           projectRoot,
           "node_modules",
           "@powerhousedao",
           "design-system"
         ),
-        "@powerhousedao/scalars": join2(
+        "@powerhousedao/scalars": join4(
           projectRoot,
           "node_modules",
           "@powerhousedao",
           "scalars"
         ),
-        "document-model-libs": join2(
+        "document-model-libs": join4(
           projectRoot,
           "node_modules",
           "document-model-libs"
         ),
-        react: join2(projectRoot, "node_modules", "react"),
-        "react-dom": join2(projectRoot, "node_modules", "react-dom")
+        react: join4(projectRoot, "node_modules", "react"),
+        "react-dom": join4(projectRoot, "node_modules", "react-dom")
       }
     },
     plugins: [
       viteConnectDevStudioPlugin(true),
-      viteLoadExternalProjects(
-        enableExternalProjects,
-        options.projectsImportPath
-      ),
+      viteLoadExternalPackages(options.packages, true),
       viteEnvs({
-        declarationFile: join2(studioDirname2, "../.env"),
+        declarationFile: join4(studioDirname2, "../.env"),
         computedEnv: studioConfig
       }),
       runShellScriptPlugin(viteEnvsScript),
@@ -430,63 +542,16 @@ async function startServer(options = {}) {
 }
 
 // studio/index.ts
-var IMPORT_SCRIPT_FILE = "projects-import.js";
-var projectRoot2 = process.cwd();
 var readJsonFile = (filePath) => {
   try {
     const absolutePath = resolve(filePath);
-    const fileContents = fs4.readFileSync(absolutePath, "utf-8");
+    const fileContents = fs5.readFileSync(absolutePath, "utf-8");
     return JSON.parse(fileContents);
   } catch (error) {
     console.error(`Error reading file: ${filePath}`);
     return null;
   }
 };
-function mapProjects(packages) {
-  if (!packages) {
-    return [];
-  }
-  return packages.map((pkg) => ({
-    name: pkg.packageName,
-    path: join3(
-      projectRoot2,
-      "node_modules",
-      pkg.packageName,
-      "dist",
-      "es",
-      "index.js"
-    )
-  }));
-}
-function generateImportSctipt(outputPath, projects) {
-  const importScriptFilePath = join3(outputPath, IMPORT_SCRIPT_FILE);
-  if (!fs4.existsSync(outputPath)) {
-    fs4.mkdirSync(outputPath, { recursive: true });
-  }
-  if (!fs4.existsSync(importScriptFilePath)) {
-    fs4.writeFileSync(importScriptFilePath, "");
-  }
-  const imports = [];
-  const moduleNames = [];
-  let counter = 0;
-  for (const project of projects) {
-    if (fs4.existsSync(project.path)) {
-      const moduleName = `module${counter}`;
-      moduleNames.push(moduleName);
-      imports.push(`import * as ${moduleName} from '${project.path}';`);
-      counter++;
-    } else {
-      console.error(
-        `Can not import project: ${project.name}, file not found: ${project.path}. Did you build the project or install it?`
-      );
-    }
-  }
-  const exportStatement = `export default [${moduleNames.join(", ")}];`;
-  const fileContent = `${imports.join("\n")}
-
-${exportStatement}`;
-  fs4.writeFileSync(importScriptFilePath, fileContent);
-}
 function startConnectStudio(options) {
   const serverOptions = {};
   if (options.port) {
@@ -501,27 +566,17 @@ function startConnectStudio(options) {
   if (options.configFile) {
     const config = readJsonFile(options.configFile);
     if (!config) return;
-    const configFileDir = dirname(options.configFile);
+    const configFileDir = dirname3(options.configFile);
     if (config.packages && config.packages.length > 0) {
-      const packages = mapProjects(config.packages);
-      generateImportSctipt(configFileDir, packages);
-      process.env.LOAD_EXTERNAL_PROJECTS = "true";
-      serverOptions.enableExternalProjects = true;
-      serverOptions.projectsImportPath = resolve(
-        configFileDir,
-        IMPORT_SCRIPT_FILE
-      );
-    } else {
-      process.env.LOAD_EXTERNAL_PROJECTS = "false";
-      serverOptions.enableExternalProjects = false;
+      serverOptions.packages = config.packages.map((p) => p.packageName);
     }
     if (config.documentModelsDir) {
       process.env.LOCAL_DOCUMENT_MODELS = isAbsolute(
         config.documentModelsDir
-      ) ? config.documentModelsDir : join3(configFileDir, config.documentModelsDir);
+      ) ? config.documentModelsDir : join5(configFileDir, config.documentModelsDir);
     }
     if (config.editorsDir) {
-      process.env.LOCAL_DOCUMENT_EDITORS = isAbsolute(config.editorsDir) ? config.editorsDir : join3(configFileDir, config.editorsDir);
+      process.env.LOCAL_DOCUMENT_EDITORS = isAbsolute(config.editorsDir) ? config.editorsDir : join5(configFileDir, config.editorsDir);
     }
     if (config.studio?.port) {
       process.env.PORT = config.studio.port.toString();
@@ -532,19 +587,9 @@ function startConnectStudio(options) {
     if (config.studio?.host) {
       process.env.HOST = config.studio.host;
     }
-  } else {
-    process.env.LOAD_EXTERNAL_PROJECTS = "false";
-    serverOptions.enableExternalProjects = false;
   }
   if (options.packages && options.packages.length > 0) {
-    const packages = mapProjects(options.packages);
-    generateImportSctipt(projectRoot2, packages);
-    process.env.LOAD_EXTERNAL_PROJECTS = "true";
-    serverOptions.enableExternalProjects = true;
-    serverOptions.projectsImportPath = resolve(
-      projectRoot2,
-      IMPORT_SCRIPT_FILE
-    );
+    serverOptions.packages = options.packages.map((p) => p.packageName);
   }
   if (options.localEditors) {
     process.env.LOCAL_DOCUMENT_EDITORS = options.localEditors;
@@ -574,7 +619,6 @@ program.command("help").description("Display help information").action(() => {
   program.help();
 });
 export {
-  generateImportSctipt,
   program,
   startConnectStudio
 };