@powerhousedao/connect 1.0.0 → 1.0.4

package/dist/studio/index.js

@@ -1,14 +1,14 @@
 // studio/index.ts
 import { Command } from "commander";
-import fs5 from "node:fs";
-import { dirname as dirname3, isAbsolute, join as join5, resolve } from "node:path";
+import fs4 from "node:fs";
+import { dirname, isAbsolute, join as join3, resolve } from "node:path";
 
 // studio/server.ts
 import basicSsl from "@vitejs/plugin-basic-ssl";
-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 { 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 { createLogger, createServer } from "vite";
 import { viteEnvs } from "vite-envs";
 
@@ -50,19 +50,14 @@ function removeBase64EnvValues() {
   });
 }
 
-// studio/vite-plugins/base.ts
-import MagicString from "magic-string";
+// studio/vite-plugin.ts
+import fs2 from "node:fs";
 import path from "node:path";
-import { normalizePath } from "vite";
-var externalIds = /^react(-dom)?(\/.*)?$/;
+import {
+  normalizePath
+} from "vite";
 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;
@@ -79,233 +74,8 @@ 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;
@@ -335,7 +105,7 @@ function watchLocalFiles(server, documentModelsPath, editorsPath) {
       `Watching local document models at '${documentModelsPath}'...`
     );
     try {
-      fs3.watch(
+      fs2.watch(
         documentModelsPath,
         {
           recursive: true
@@ -351,7 +121,7 @@ function watchLocalFiles(server, documentModelsPath, editorsPath) {
   if (editorsPath) {
     console.log(`Watching local document editors at '${editorsPath}'...`);
     try {
-      fs3.watch(
+      fs2.watch(
         editorsPath,
         {
           recursive: true
@@ -365,8 +135,58 @@ 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 [
@@ -376,36 +196,42 @@ 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 (!config.build) {
-          config.build = {};
+        if (!localDocumentModelsPath && !localDocumentEditorsPath) {
+          return;
         }
-        if (!config.build.rollupOptions) {
-          config.build.rollupOptions = {};
+        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 (!Array.isArray(config.build.rollupOptions.external)) {
-          config.build.rollupOptions.external = [];
+        if (resolvedAlias) {
+          resolve2.alias = resolvedAlias;
+          config.resolve = resolve2;
         }
-        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(
@@ -413,15 +239,73 @@ 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 = fileURLToPath3(new URL(".", import.meta.url));
-var appPath2 = join4(studioDirname2, "..");
-var viteEnvsScript = join4(appPath2, "vite-envs.sh");
+var studioDirname2 = fileURLToPath2(new URL(".", import.meta.url));
+var appPath2 = join2(studioDirname2, "..");
+var viteEnvsScript = join2(appPath2, "vite-envs.sh");
 var projectRoot = process.cwd();
 var logger = createLogger();
 var loggerWarn = logger.warn;
@@ -447,8 +331,8 @@ function runShellScriptPlugin(scriptPath) {
   return {
     name: "vite-plugin-run-shell-script",
     buildStart() {
-      if (fs4.existsSync(scriptPath)) {
-        exec2(`sh ${scriptPath}`, (error, stdout, stderr) => {
+      if (fs3.existsSync(scriptPath)) {
+        exec(`sh ${scriptPath}`, (error, stdout, stderr) => {
           if (error) {
             console.error(
               `Error executing the script: ${error.message}`
@@ -465,14 +349,15 @@ 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 (!fs4.existsSync(join4(appPath2, "src"))) {
-    fs4.mkdirSync(join4(appPath2, "src"));
+  if (!fs3.existsSync(join2(appPath2, "src"))) {
+    fs3.mkdirSync(join2(appPath2, "src"));
   }
   process.env.PH_CONNECT_STUDIO_MODE = "true";
   const config = {
@@ -488,7 +373,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": join4(
+        "@powerhousedao/design-system/scalars": join2(
           projectRoot,
           "node_modules",
           "@powerhousedao",
@@ -496,32 +381,35 @@ async function startServer(options = {}) {
           "dist",
           "scalars"
         ),
-        "@powerhousedao/design-system": join4(
+        "@powerhousedao/design-system": join2(
           projectRoot,
           "node_modules",
           "@powerhousedao",
           "design-system"
         ),
-        "@powerhousedao/scalars": join4(
+        "@powerhousedao/scalars": join2(
           projectRoot,
           "node_modules",
           "@powerhousedao",
           "scalars"
         ),
-        "document-model-libs": join4(
+        "document-model-libs": join2(
           projectRoot,
           "node_modules",
           "document-model-libs"
         ),
-        react: join4(projectRoot, "node_modules", "react"),
-        "react-dom": join4(projectRoot, "node_modules", "react-dom")
+        react: join2(projectRoot, "node_modules", "react"),
+        "react-dom": join2(projectRoot, "node_modules", "react-dom")
       }
     },
     plugins: [
       viteConnectDevStudioPlugin(true),
-      viteLoadExternalPackages(options.packages, true),
+      viteLoadExternalProjects(
+        enableExternalProjects,
+        options.projectsImportPath
+      ),
       viteEnvs({
-        declarationFile: join4(studioDirname2, "../.env"),
+        declarationFile: join2(studioDirname2, "../.env"),
         computedEnv: studioConfig
       }),
       runShellScriptPlugin(viteEnvsScript),
@@ -542,16 +430,63 @@ 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 = fs5.readFileSync(absolutePath, "utf-8");
+    const fileContents = fs4.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) {
@@ -566,17 +501,27 @@ function startConnectStudio(options) {
   if (options.configFile) {
     const config = readJsonFile(options.configFile);
     if (!config) return;
-    const configFileDir = dirname3(options.configFile);
+    const configFileDir = dirname(options.configFile);
     if (config.packages && config.packages.length > 0) {
-      serverOptions.packages = config.packages.map((p) => p.packageName);
+      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;
     }
     if (config.documentModelsDir) {
       process.env.LOCAL_DOCUMENT_MODELS = isAbsolute(
         config.documentModelsDir
-      ) ? config.documentModelsDir : join5(configFileDir, config.documentModelsDir);
+      ) ? config.documentModelsDir : join3(configFileDir, config.documentModelsDir);
     }
     if (config.editorsDir) {
-      process.env.LOCAL_DOCUMENT_EDITORS = isAbsolute(config.editorsDir) ? config.editorsDir : join5(configFileDir, config.editorsDir);
+      process.env.LOCAL_DOCUMENT_EDITORS = isAbsolute(config.editorsDir) ? config.editorsDir : join3(configFileDir, config.editorsDir);
     }
     if (config.studio?.port) {
       process.env.PORT = config.studio.port.toString();
@@ -587,9 +532,19 @@ 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) {
-    serverOptions.packages = options.packages.map((p) => p.packageName);
+    const packages = mapProjects(options.packages);
+    generateImportSctipt(projectRoot2, packages);
+    process.env.LOAD_EXTERNAL_PROJECTS = "true";
+    serverOptions.enableExternalProjects = true;
+    serverOptions.projectsImportPath = resolve(
+      projectRoot2,
+      IMPORT_SCRIPT_FILE
+    );
   }
   if (options.localEditors) {
     process.env.LOCAL_DOCUMENT_EDITORS = options.localEditors;
@@ -619,6 +574,7 @@ program.command("help").description("Display help information").action(() => {
   program.help();
 });
 export {
+  generateImportSctipt,
   program,
   startConnectStudio
 };