piral-cli 0.15.0-beta.4630 → 0.15.0-beta.4670

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "piral-cli",
-  "version": "0.15.0-beta.4630",
+  "version": "0.15.0-beta.4670",
   "description": "The standard CLI for creating and building a Piral instance or a Pilet.",
   "keywords": [
     "portal",
@@ -73,10 +73,10 @@
   "dependencies": {
     "chalk": "^2.4.2",
     "dets": "^0.12.0",
-    "kras": "^0.15.0",
+    "kras": "^0.15.1",
     "rimraf": "^3.0.0",
     "typescript": "^4.7.3",
     "yargs": "^15.4.1"
   },
-  "gitHead": "08aea96af9587e73b1a6c4eb108f94f285186b10"
+  "gitHead": "ffd8707600e028a55258028d394b76fe3a0cd175"
 }

package/src/apps/build-pilet.ts

@@ -212,8 +212,8 @@ export async function buildPilet(baseDir = process.cwd(), options: BuildPiletOpt
       targetDir,
       app,
     );
-    const piral = apps[0].appPackage.name;
-    const externals = combinePiletExternals([piral], peerDependencies, peerModules, importmap);
+    const piralInstances = apps.map(m => m.appPackage.name);
+    const externals = combinePiletExternals(piralInstances, peerDependencies, peerModules, importmap);
     const dest = resolve(root, target);
     const outDir = dirname(dest);
     const outFile = basename(dest);
@@ -230,7 +230,7 @@ export async function buildPilet(baseDir = process.cwd(), options: BuildPiletOpt
     await callPiletBuild(
       {
         root,
-        piral,
+        piralInstances,
         optimizeModules,
         sourceMaps,
         contentHash,
@@ -282,7 +282,9 @@ export async function buildPilet(baseDir = process.cwd(), options: BuildPiletOpt
     const distDir = dirname(resolve(fullBase, target));
     const outDir = resolve(distDir, 'standalone');
     const { apps, root } = pilets[0];
+
     const { appPackage, appFile } = apps[0];
+    const piralInstances = [appPackage.name];
     const isEmulator = checkAppShellPackage(appPackage);
 
     logInfo('Building standalone solution ...');
@@ -306,7 +308,7 @@ export async function buildPilet(baseDir = process.cwd(), options: BuildPiletOpt
       await callPiralBuild(
         {
           root,
-          piral: appPackage.name,
+          piralInstances,
           emulator: false,
           standalone: true,
           optimizeModules: false,
@@ -331,7 +333,7 @@ export async function buildPilet(baseDir = process.cwd(), options: BuildPiletOpt
       await callPiralBuild(
         {
           root,
-          piral: appPackage.name,
+          piralInstances,
           emulator: false,
           standalone: true,
           optimizeModules: false,

package/src/apps/build-piral.ts

@@ -156,6 +156,7 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
   progress('Reading configuration ...');
   const entryFiles = await retrievePiralRoot(fullBase, entry);
   const { name, root, ignored, externals, scripts } = await retrievePiletsInfo(entryFiles);
+  const piralInstances = [name];
   const dest = getDestination(entryFiles, resolve(fullBase, target));
 
   await checkCliCompatibility(root);
@@ -174,7 +175,7 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
     // since we create this anyway let's just pretend we want to have it clean!
     await removeDirectory(targetDir);
 
-    await hooks.beforeBuild?.({ root, publicUrl: emulatorPublicUrl, externals, entryFiles, targetDir, name });
+    await hooks.beforeBuild?.({ root, publicUrl: emulatorPublicUrl, externals, entryFiles, targetDir, piralInstances });
 
     logInfo(`Bundle ${emulatorName} ...`);
     const {
@@ -184,7 +185,7 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
     } = await callPiralBuild(
       {
         root,
-        piral: name,
+        piralInstances,
         emulator: true,
         standalone: false,
         optimizeModules,
@@ -209,7 +210,7 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
       externals,
       entryFiles,
       targetDir,
-      name,
+      piralInstances,
       hash,
       outDir,
       outFile,
@@ -246,7 +247,7 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
 
     logInfo(`Bundle ${releaseName} ...`);
 
-    await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, targetDir, name });
+    await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, targetDir, piralInstances });
 
     const {
       dir: outDir,
@@ -255,7 +256,7 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
     } = await callPiralBuild(
       {
         root,
-        piral: name,
+        piralInstances,
         emulator: false,
         standalone: false,
         optimizeModules,
@@ -274,7 +275,7 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
       bundlerName,
     );
 
-    await hooks.afterBuild?.({ root, publicUrl, externals, entryFiles, targetDir, name, outDir, outFile, hash });
+    await hooks.afterBuild?.({ root, publicUrl, externals, entryFiles, targetDir, piralInstances, outDir, outFile, hash });
 
     await runLifecycle(root, scripts, 'piral:postbuild');
     await runLifecycle(root, scripts, `piral:postbuild-${releaseName}`);

package/src/apps/debug-pilet.ts

@@ -1,7 +1,7 @@
 import { join, dirname, resolve, relative, basename } from 'path';
-import { readKrasConfig, krasrc, buildKrasWithCli, defaultConfig } from 'kras';
+import { readKrasConfig, krasrc, buildKrasWithCli } from 'kras';
 import { callDebugPiralFromMonoRepo, callPiletDebug } from '../bundler';
-import { LogLevels, PiletSchemaVersion } from '../types';
+import { AppDefinition, LogLevels, PiletSchemaVersion } from '../types';
 import {
   checkExistingDirectory,
   retrievePiletData,
@@ -22,6 +22,7 @@ import {
   createInitialKrasConfig,
   getAvailablePort,
   combinePiletExternals,
+  watcherTask,
 } from '../common';
 
 export interface DebugPiletOptions {
@@ -133,46 +134,60 @@ export const debugPiletDefaults: DebugPiletOptions = {
   concurrency: cpuCount,
 };
 
-const injectorName = resolve(__dirname, '../injectors/pilet.js');
-
 interface AppInfo {
-  emulator: boolean;
-  appFile: string;
+  apps: Array<AppDefinition>;
+  root: string;
+  mocks: string;
   publicUrl: string;
-  appVersion: string;
   externals: Array<string>;
-  piral: string;
 }
 
-async function getOrMakeAppDir({ emulator, piral, appFile, publicUrl }: AppInfo, logLevel: LogLevels) {
-  if (!emulator) {
-    const { externals, root, ignored } = await retrievePiletsInfo(appFile);
-    const { dir } = await callDebugPiralFromMonoRepo({
-      root,
-      optimizeModules: false,
-      publicUrl,
-      ignored,
-      externals,
-      piral,
-      entryFiles: appFile,
-      logLevel,
-      _: {},
-    });
-    return dir;
-  }
-
-  return dirname(appFile);
+function getOrMakeApps({ apps, publicUrl }: AppInfo, logLevel: LogLevels) {
+  return Promise.all(
+    apps.map(async ({ emulator, appFile, appPackage }) => {
+      if (!emulator) {
+        const piralInstances = [appPackage.name];
+        const { externals, root, ignored } = await retrievePiletsInfo(appFile);
+        const { dir } = await callDebugPiralFromMonoRepo({
+          root,
+          optimizeModules: false,
+          publicUrl,
+          ignored,
+          externals,
+          piralInstances,
+          entryFiles: appFile,
+          logLevel,
+          _: {},
+        });
+        return dir;
+      }
+
+      return dirname(appFile);
+    }),
+  );
 }
 
 function checkSanity(pilets: Array<AppInfo>) {
   for (let i = 1; i < pilets.length; i++) {
     const previous = pilets[i - 1];
     const current = pilets[i];
-
-    if (previous.piral !== current.piral) {
-      return log('piletMultiDebugAppShellDifferent_0301', previous.piral, current.piral);
-    } else if (previous.appVersion !== current.appVersion) {
-      return log('piletMultiDebugAppShellVersions_0302', previous.appVersion, current.appVersion);
+    const previousInstances = previous.apps;
+    const currentInstances = current.apps;
+    const previousInstancesNames = previousInstances
+      .map((m) => m.appPackage.name)
+      .sort()
+      .join(', ');
+    const currentInstancesNames = currentInstances
+      .map((m) => m.appPackage.name)
+      .sort()
+      .join(', ');
+    const previousInstancesVersions = previousInstances.map((m) => m.appPackage.version).join(', ');
+    const currentInstancesVersions = currentInstances.map((m) => m.appPackage.version).join(', ');
+
+    if (previousInstancesNames !== currentInstancesNames) {
+      return log('piletMultiDebugAppShellDifferent_0301', previousInstancesNames, currentInstancesNames);
+    } else if (previousInstancesVersions !== currentInstancesVersions) {
+      return log('piletMultiDebugAppShellVersions_0302', previousInstancesVersions, currentInstancesVersions);
     } else if (previous.externals.length !== current.externals.length) {
       return log('piletMultiDebugExternalsDifferent_0303', previous.externals, current.externals);
     } else if (previous.externals.some((m) => !current.externals.includes(m))) {
@@ -202,130 +217,148 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
   } = options;
   const publicUrl = normalizePublicUrl(originalPublicUrl);
   const fullBase = resolve(process.cwd(), baseDir);
+  const port = await getAvailablePort(originalPort);
   setLogLevel(logLevel);
 
   await hooks.onBegin?.({ options, fullBase });
-  progress('Reading configuration ...');
-  const api = `${publicUrl}${config.piletApi.replace(/^\/+/, '')}`;
-  const entryList = Array.isArray(entry) ? entry : [entry];
-  const multi = entryList.length > 1 || entryList[0].indexOf('*') !== -1;
-  log('generalDebug_0003', `Looking for (${multi ? 'multi' : 'single'}) "${entryList.join('", "')}" in "${fullBase}".`);
-
-  const allEntries = await matchAnyPilet(fullBase, entryList);
-  const maxListeners = Math.max(2 + allEntries.length * 2, 16);
-  log('generalDebug_0003', `Found the following entries: ${allEntries.join(', ')}`);
-
-  if (allEntries.length === 0) {
-    fail('entryFileMissing_0077');
-  }
 
-  process.stderr.setMaxListeners(maxListeners);
-  process.stdout.setMaxListeners(maxListeners);
-  process.stdin.setMaxListeners(maxListeners);
-
-  const pilets = await concurrentWorkers(allEntries, concurrency, async (entryModule) => {
-    const targetDir = dirname(entryModule);
-    const { peerDependencies, peerModules, root, apps, ignored, importmap } = await retrievePiletData(targetDir, app);
-    const { appPackage, appFile, emulator } = apps[0];
-    const piral = appPackage.name;
-    const externals = combinePiletExternals([piral], peerDependencies, peerModules, importmap);
-    const mocks = join(targetDir, 'mocks');
-    const dest = resolve(root, target);
-    const outDir = dirname(dest);
-    const outFile = basename(dest);
-    const mocksExists = await checkExistingDirectory(mocks);
-
-    await hooks.beforeBuild?.({ root, publicUrl, importmap, entryModule, schemaVersion });
-
-    const bundler = await callPiletDebug(
-      {
-        root,
-        piral,
-        optimizeModules,
-        hmr,
-        externals,
-        targetDir,
-        importmap,
-        outFile,
-        outDir,
-        entryModule: `./${relative(root, entryModule)}`,
-        logLevel,
-        version: schemaVersion,
-        ignored,
-        _,
-      },
-      bundlerName,
+  await watcherTask(async (watcherContext) => {
+    progress('Reading configuration ...');
+    const api = `${publicUrl}${config.piletApi.replace(/^\/+/, '')}`;
+    const entryList = Array.isArray(entry) ? entry : [entry];
+    const multi = entryList.length > 1 || entryList[0].indexOf('*') !== -1;
+    log(
+      'generalDebug_0003',
+      `Looking for (${multi ? 'multi' : 'single'}) "${entryList.join('", "')}" in "${fullBase}".`,
     );
 
-    bundler.on((args) => {
-      hooks.afterBuild?.({ ...args, root, publicUrl, importmap, entryModule, schemaVersion, bundler, outFile, outDir });
-    });
+    const allEntries = await matchAnyPilet(fullBase, entryList);
+    const maxListeners = Math.max(2 + allEntries.length * 2, 16);
+    log('generalDebug_0003', `Found the following entries: ${allEntries.join(', ')}`);
 
-    return {
-      emulator,
-      appFile,
-      publicUrl,
-      appVersion: appPackage.version,
-      externals,
-      piral: appPackage.name,
-      bundler,
-      mocks: mocksExists ? mocks : undefined,
-      root,
-    };
-  });
+    if (allEntries.length === 0) {
+      fail('entryFileMissing_0077');
+    }
 
-  // sanity check see #250
-  checkSanity(pilets);
-
-  await hooks.beforeApp?.({ appInstanceDir, pilets });
-  const appDir = appInstanceDir || (await getOrMakeAppDir(pilets[0], logLevel));
-  const appRoot = dirname(await findFile(appDir, 'package.json'));
-  await hooks.afterApp?.({ appInstanceDir, pilets });
-
-  Promise.all(pilets.map((p) => p.bundler.ready())).then(() => logDone(`Ready!`));
-
-  const sources = pilets.map((m) => m.mocks).filter(Boolean);
-  const baseMocks = resolve(fullBase, 'mocks');
-  const krasBaseConfig = resolve(fullBase, krasrc);
-  const krasRootConfig = resolve(appRoot, krasrc);
-  const initial = createInitialKrasConfig(baseMocks, sources, { [api]: '' }, feed);
-  const required = {
-    injectors: {
-      piral: {
-        active: false,
-      },
-      pilet: {
-        active: true,
-        pilets,
-        app: appDir,
+    process.stderr.setMaxListeners(maxListeners);
+    process.stdout.setMaxListeners(maxListeners);
+    process.stdin.setMaxListeners(maxListeners);
+
+    const pilets = await concurrentWorkers(allEntries, concurrency, async (entryModule) => {
+      const targetDir = dirname(entryModule);
+      const { peerDependencies, peerModules, root, apps, ignored, importmap } = await retrievePiletData(targetDir, app);
+      const piralInstances = apps.map((m) => m.appPackage.name);
+      const externals = combinePiletExternals(piralInstances, peerDependencies, peerModules, importmap);
+      const mocks = join(targetDir, 'mocks');
+      const dest = resolve(root, target);
+      const outDir = dirname(dest);
+      const outFile = basename(dest);
+      const mocksExists = await checkExistingDirectory(mocks);
+
+      await hooks.beforeBuild?.({ root, publicUrl, importmap, entryModule, schemaVersion });
+
+      const bundler = await callPiletDebug(
+        {
+          root,
+          piralInstances,
+          optimizeModules,
+          hmr,
+          externals,
+          targetDir,
+          importmap,
+          outFile,
+          outDir,
+          entryModule: `./${relative(root, entryModule)}`,
+          logLevel,
+          version: schemaVersion,
+          ignored,
+          _,
+        },
+        bundlerName,
+      );
+
+      bundler.on((args) => {
+        hooks.afterBuild?.({
+          ...args,
+          root,
+          publicUrl,
+          importmap,
+          entryModule,
+          schemaVersion,
+          bundler,
+          outFile,
+          outDir,
+        });
+      });
+
+      return {
+        apps,
         publicUrl,
-        handle: ['/', api],
-        api,
-      },
-    },
-  };
-  const configs = [krasBaseConfig, ...pilets.map((p) => resolve(p.root, krasrc)), krasRootConfig];
-  const port = await getAvailablePort(originalPort);
-  const krasConfig = readKrasConfig({ port, initial, required }, ...configs);
-
-  log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
-
-  const krasServer = buildKrasWithCli(krasConfig);
-  krasServer.setMaxListeners(maxListeners);
-  krasServer.removeAllListeners('open');
-  krasServer.on(
-    'open',
-    notifyServerOnline(
-      pilets.map((p) => p.bundler),
-      publicUrl,
-      krasConfig.api,
-    ),
-  );
+        externals,
+        bundler,
+        mocks: mocksExists ? mocks : undefined,
+        root,
+      };
+    });
+
+    // sanity check see #250
+    checkSanity(pilets);
+
+    await hooks.beforeApp?.({ appInstanceDir, pilets });
+    const appDirs = [appInstanceDir] || (await getOrMakeApps(pilets[0], logLevel));
+
+    await Promise.all(
+      appDirs.map(async (appDir) => {
+        const appRoot = dirname(await findFile(appDir, 'package.json'));
+        await hooks.afterApp?.({ appInstanceDir, pilets });
+
+        Promise.all(pilets.map((p) => p.bundler.ready())).then(() => logDone(`Ready!`));
+
+        const sources = pilets.map((m) => m.mocks).filter(Boolean);
+        const baseMocks = resolve(fullBase, 'mocks');
+        const krasBaseConfig = resolve(fullBase, krasrc);
+        const krasRootConfig = resolve(appRoot, krasrc);
+        const initial = createInitialKrasConfig(baseMocks, sources, { [api]: '' }, feed);
+        const required = {
+          injectors: {
+            piral: {
+              active: false,
+            },
+            pilet: {
+              active: true,
+              pilets,
+              app: appDir,
+              publicUrl,
+              handle: ['/', api],
+              api,
+            },
+          },
+        };
+        const configs = [krasBaseConfig, ...pilets.map((p) => resolve(p.root, krasrc)), krasRootConfig];
+        const krasConfig = readKrasConfig({ port, initial, required }, ...configs);
+
+        log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
+
+        const krasServer = buildKrasWithCli(krasConfig);
+        krasServer.setMaxListeners(maxListeners);
+        krasServer.removeAllListeners('open');
+        krasServer.on(
+          'open',
+          notifyServerOnline(
+            pilets.map((p) => p.bundler),
+            publicUrl,
+            krasConfig.api,
+          ),
+        );
+
+        await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets, publicUrl });
+        await krasServer.start();
+        openBrowser(open, port, publicUrl, !!krasConfig.ssl);
+        await hooks.afterOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets, publicUrl });
+        await new Promise((resolve) => krasServer.on('close', resolve));
+      }),
+    );
+  });
 
-  await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets, publicUrl });
-  await krasServer.start();
-  openBrowser(open, port, publicUrl, !!krasConfig.ssl);
-  await hooks.afterOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets, publicUrl });
-  await new Promise((resolve) => krasServer.on('close', resolve));
   await hooks.onEnd?.({});
 }

package/src/apps/debug-piral.ts

@@ -18,6 +18,7 @@ import {
   createInitialKrasConfig,
   getAvailablePort,
   checkExistingDirectory,
+  watcherTask,
 } from '../common';
 
 export interface DebugPiralOptions {
@@ -118,76 +119,83 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
   } = options;
   const publicUrl = normalizePublicUrl(originalPublicUrl);
   const fullBase = resolve(process.cwd(), baseDir);
+  const port = await getAvailablePort(originalPort);
   setLogLevel(logLevel);
 
   await hooks.onBegin?.({ options, fullBase });
-  progress('Reading configuration ...');
-  const entryFiles = await retrievePiralRoot(fullBase, entry);
-  const targetDir = dirname(entryFiles);
-  const { externals, name, root, ignored } = await retrievePiletsInfo(entryFiles);
-  const dest = getDestination(entryFiles, resolve(fullBase, target));
-
-  await checkCliCompatibility(root);
-
-  await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, name });
-
-  const bundler = await callPiralDebug(
-    {
-      root,
-      piral: name,
-      optimizeModules,
-      hmr,
-      externals,
-      publicUrl,
-      entryFiles,
-      logLevel,
-      ignored,
-      ...dest,
-      _,
-    },
-    bundlerName,
-  );
-
-  bundler.ready().then(() => logDone(`Ready!`));
-
-  bundler.on((args) => {
-    hooks.afterBuild?.({ ...args, root, publicUrl, externals, entryFiles, name, bundler, ...dest });
-  });
 
-  const krasBaseConfig = resolve(fullBase, krasrc);
-  const krasRootConfig = resolve(root, krasrc);
-  const mocks = join(targetDir, 'mocks');
-  const baseMocks = resolve(fullBase, 'mocks');
-  const mocksExist = await checkExistingDirectory(mocks);
-  const sources = [mocksExist ? mocks : undefined].filter(Boolean);
-  const initial = createInitialKrasConfig(baseMocks, sources);
-  const required = {
-    injectors: {
-      piral: {
-        active: true,
-        handle: ['/'],
-        feed,
+  await watcherTask(async (watcherContext) => {
+    progress('Reading configuration ...');
+    const entryFiles = await retrievePiralRoot(fullBase, entry);
+    const targetDir = dirname(entryFiles);
+    const { externals, name, root, ignored } = await retrievePiletsInfo(entryFiles);
+    const piralInstances = [name];
+    const dest = getDestination(entryFiles, resolve(fullBase, target));
+
+    await checkCliCompatibility(root);
+
+    await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, piralInstances });
+
+    const bundler = await callPiralDebug(
+      {
+        root,
+        piralInstances,
+        optimizeModules,
+        hmr,
+        externals,
         publicUrl,
-        bundler,
+        entryFiles,
+        logLevel,
+        ignored,
+        ...dest,
+        _,
       },
-      pilet: {
-        active: false,
+      bundlerName,
+    );
+
+    bundler.ready().then(() => logDone(`Ready!`));
+
+    bundler.on((args) => {
+      hooks.afterBuild?.({ ...args, root, publicUrl, externals, entryFiles, piralInstances, bundler, ...dest });
+    });
+
+    const krasBaseConfig = resolve(fullBase, krasrc);
+    const krasRootConfig = resolve(root, krasrc);
+    const mocks = join(targetDir, 'mocks');
+    const baseMocks = resolve(fullBase, 'mocks');
+
+
+    const mocksExist = await checkExistingDirectory(mocks);
+    const sources = [mocksExist ? mocks : undefined].filter(Boolean);
+    const initial = createInitialKrasConfig(baseMocks, sources);
+    const required = {
+      injectors: {
+        piral: {
+          active: true,
+          handle: ['/'],
+          feed,
+          publicUrl,
+          bundler,
+        },
+        pilet: {
+          active: false,
+        },
       },
-    },
-  };
-  const port = await getAvailablePort(originalPort);
-  const krasConfig = readKrasConfig({ port, initial, required }, krasBaseConfig, krasRootConfig);
+    };
+    const krasConfig = readKrasConfig({ port, initial, required }, krasBaseConfig, krasRootConfig);
 
-  log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
+    log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
 
-  const krasServer = buildKrasWithCli(krasConfig);
-  krasServer.removeAllListeners('open');
-  krasServer.on('open', notifyServerOnline([bundler], publicUrl, krasConfig.api));
+    const krasServer = buildKrasWithCli(krasConfig);
+    krasServer.removeAllListeners('open');
+    krasServer.on('open', notifyServerOnline([bundler], publicUrl, krasConfig.api));
+
+    await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, publicUrl });
+    await krasServer.start();
+    openBrowser(open, port, publicUrl, !!krasConfig.ssl);
+    await hooks.afterOnline?.({ krasServer, krasConfig, open, port, publicUrl });
+    await new Promise((resolve) => krasServer.on('close', resolve));
+  });
 
-  await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, publicUrl });
-  await krasServer.start();
-  openBrowser(open, port, publicUrl, !!krasConfig.ssl);
-  await hooks.afterOnline?.({ krasServer, krasConfig, open, port, publicUrl });
-  await new Promise((resolve) => krasServer.on('close', resolve));
   await hooks.onEnd?.({});
 }