piral-cli 0.15.0-alpha.4231 → 0.15.0-alpha.4311

package/src/apps/debug-piral.ts

@@ -1,5 +1,5 @@
 import { dirname, join, resolve } from 'path';
-import { readKrasConfig, krasrc, buildKrasWithCli, defaultConfig } from 'kras';
+import { readKrasConfig, krasrc, buildKrasWithCli } from 'kras';
 import { callPiralDebug } from '../bundler';
 import { LogLevels } from '../types';
 import {
@@ -7,7 +7,6 @@ import {
   retrievePiralRoot,
   openBrowser,
   checkCliCompatibility,
-  reorderInjectors,
   notifyServerOnline,
   setLogLevel,
   progress,
@@ -16,6 +15,8 @@ import {
   normalizePublicUrl,
   logDone,
   getDestination,
+  createInitialKrasConfig,
+  getAvailablePort,
 } from '../common';
 
 export interface DebugPiralOptions {
@@ -99,15 +100,13 @@ export const debugPiralDefaults: DebugPiralOptions = {
   optimizeModules: false,
 };
 
-const injectorName = resolve(__dirname, '../injectors/piral.js');
-
 export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOptions = {}) {
   const {
     entry = debugPiralDefaults.entry,
     target = debugPiralDefaults.target,
-    port = debugPiralDefaults.port,
     open = debugPiralDefaults.open,
     hmr = debugPiralDefaults.hmr,
+    port: originalPort = debugPiralDefaults.port,
     publicUrl: originalPublicUrl = debugPiralDefaults.publicUrl,
     logLevel = debugPiralDefaults.logLevel,
     optimizeModules = debugPiralDefaults.optimizeModules,
@@ -125,30 +124,9 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
   const entryFiles = await retrievePiralRoot(fullBase, entry);
   const { externals, name, root, ignored } = await retrievePiletsInfo(entryFiles);
   const dest = getDestination(entryFiles, resolve(fullBase, target));
-  const krasConfig = readKrasConfig({ port }, krasrc);
 
   await checkCliCompatibility(root);
 
-  if (krasConfig.directory === undefined) {
-    krasConfig.directory = join(dirname(entryFiles), 'mocks');
-  }
-
-  if (krasConfig.ssl === undefined) {
-    krasConfig.ssl = undefined;
-  }
-
-  if (krasConfig.map === undefined) {
-    krasConfig.map = {};
-  }
-
-  if (krasConfig.api === undefined) {
-    krasConfig.api = '/manage-mock-server';
-  }
-
-  if (krasConfig.injectors === undefined) {
-    krasConfig.injectors = defaultConfig.injectors;
-  }
-
   await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, name });
 
   const bundler = await callPiralDebug(
@@ -174,18 +152,25 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
     hooks.afterBuild?.({ ...args, root, publicUrl, externals, entryFiles, name, bundler, ...dest });
   });
 
-  const { piral: piralInjector, ...otherInjectors } = krasConfig.injectors;
-  const injectorConfig = {
-    ...piralInjector,
-    feed,
-    active: true,
-    handle: ['/'],
-    publicUrl,
-    bundler,
+  const krasBaseConfig = resolve(fullBase, krasrc);
+  const krasRootConfig = resolve(root, krasrc);
+  const initial = createInitialKrasConfig(join(dirname(entryFiles), 'mocks'));
+  const required = {
+    injectors: {
+      piral: {
+        active: true,
+        handle: ['/'],
+        feed,
+        publicUrl,
+        bundler,
+      },
+      pilet: {
+        active: false,
+      },
+    },
   };
-
-  krasConfig.map['/'] = '';
-  krasConfig.injectors = reorderInjectors(injectorName, injectorConfig, otherInjectors);
+  const port = await getAvailablePort(originalPort);
+  const krasConfig = readKrasConfig({ port, initial, required }, krasBaseConfig, krasRootConfig);
 
   log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
 

package/src/apps/new-pilet.ts

@@ -102,7 +102,7 @@ export const newPiletDefaults: NewPiletOptions = {
   install: true,
   template: undefined,
   logLevel: LogLevels.info,
-  npmClient: config.npmClient,
+  npmClient: undefined,
   bundlerName: 'none',
   variables: {},
 };
@@ -119,6 +119,7 @@ export async function newPilet(baseDir = process.cwd(), options: NewPiletOptions
     logLevel = newPiletDefaults.logLevel,
     bundlerName = newPiletDefaults.bundlerName,
     variables = newPiletDefaults.variables,
+    npmClient: defaultNpmClient = newPiletDefaults.npmClient,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   const root = resolve(fullBase, target);
@@ -128,7 +129,7 @@ export async function newPilet(baseDir = process.cwd(), options: NewPiletOptions
   const success = await createDirectory(root);
 
   if (success) {
-    const npmClient = await determineNpmClient(root, options.npmClient);
+    const npmClient = await determineNpmClient(root, defaultNpmClient);
     const projectName = basename(root);
 
     progress(`Scaffolding new pilet in %s ...`, root);

package/src/apps/new-piral.ts

@@ -1,4 +1,5 @@
 import { resolve, basename } from 'path';
+import { frameworkKeys } from '../helpers';
 import { LogLevels, Framework, NpmClientType } from '../types';
 import {
   ForceOverwrite,
@@ -100,7 +101,7 @@ export const newPiralDefaults: NewPiralOptions = {
   install: true,
   template: 'default',
   logLevel: LogLevels.info,
-  npmClient: config.npmClient,
+  npmClient: undefined,
   bundlerName: 'none',
   variables: {},
 };
@@ -119,15 +120,21 @@ export async function newPiral(baseDir = process.cwd(), options: NewPiralOptions
     logLevel = newPiralDefaults.logLevel,
     bundlerName = newPiralDefaults.bundlerName,
     variables = newPiralDefaults.variables,
+    npmClient: defaultNpmClient = newPiralDefaults.npmClient,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   const root = resolve(fullBase, target);
+
+  if (!frameworkKeys.includes(framework)) {
+    fail('generalError_0002', `The "framework" value must be one of: ${frameworkKeys.join(', ')}`);
+  }
+
   setLogLevel(logLevel);
   progress('Preparing source and target ...');
   const success = await createDirectory(root);
 
   if (success) {
-    const npmClient = await determineNpmClient(root, options.npmClient);
+    const npmClient = await determineNpmClient(root, defaultNpmClient);
     const packageRef = combinePackageRef(framework, version, 'registry');
     const projectName = basename(root);
 

package/src/apps/publish-piral.ts

@@ -1,7 +1,17 @@
 import { resolve } from 'path';
 import { publishArtifacts } from '../release';
+import {
+  setLogLevel,
+  progress,
+  checkExists,
+  fail,
+  logDone,
+  logReset,
+  publishNpmPackage,
+  matchFiles,
+  log,
+} from '../common';
 import { LogLevels, PiralBuildType } from '../types';
-import { setLogLevel, progress, checkExists, fail, logDone, logReset, publishNpmPackage, matchFiles } from '../common';
 
 export interface PublishPiralOptions {
   /**
@@ -15,9 +25,9 @@ export interface PublishPiralOptions {
   logLevel?: LogLevels;
 
   /**
-   * The additional fields to supply for the provider.
+   * The options to supply for the provider.
    */
-  fields?: Record<string, string>;
+  opts?: Record<string, string>;
 
   /**
    * Defines if authorization tokens can be retrieved interactively.
@@ -40,7 +50,7 @@ export const publishPiralDefaults: PublishPiralOptions = {
   logLevel: LogLevels.info,
   type: 'all',
   provider: 'none',
-  fields: {},
+  opts: {},
   interactive: false,
 };
 
@@ -59,6 +69,7 @@ async function publishEmulator(
   }
 
   const files = await matchFiles(directory, '*.tgz');
+  log('generalDebug_0003', `Found ${files.length} in "${directory}": ${files.join(', ')}`);
 
   if (files.length !== 1) {
     fail('publishEmulatorFilesUnexpected_0111', directory);
@@ -70,8 +81,7 @@ async function publishEmulator(
     return p;
   }, [] as Array<string>);
 
-  //TODO support interactive here, too?
-  await publishNpmPackage(directory, file, flags);
+  await publishNpmPackage(directory, file, flags, interactive);
 }
 
 async function publishRelease(
@@ -90,7 +100,8 @@ async function publishRelease(
   }
 
   const files = await matchFiles(directory, '**/*');
-  await publishArtifacts(providerName, files, args, interactive);
+  log('generalDebug_0003', `Found ${files.length} in "${directory}": ${files.join(', ')}`);
+  await publishArtifacts(providerName, directory, files, args, interactive);
 }
 
 export async function publishPiral(baseDir = process.cwd(), options: PublishPiralOptions = {}) {
@@ -98,7 +109,7 @@ export async function publishPiral(baseDir = process.cwd(), options: PublishPira
     source = publishPiralDefaults.source,
     type = publishPiralDefaults.type,
     logLevel = publishPiralDefaults.logLevel,
-    fields = publishPiralDefaults.fields,
+    opts = publishPiralDefaults.opts,
     provider = publishPiralDefaults.provider,
     interactive = publishPiralDefaults.interactive,
   } = options;
@@ -113,14 +124,14 @@ export async function publishPiral(baseDir = process.cwd(), options: PublishPira
 
   if (type !== 'release') {
     progress('Publishing emulator package ...');
-    await publishEmulator(fullBase, source, fields, interactive);
+    await publishEmulator(fullBase, source, opts, interactive);
     logDone(`Successfully published emulator.`);
     logReset();
   }
 
   if (type !== 'emulator') {
     progress('Publishing release files ...');
-    await publishRelease(fullBase, source, provider, fields, interactive);
+    await publishRelease(fullBase, source, provider, opts, interactive);
     logDone(`Successfully published release.`);
     logReset();
   }

package/src/apps/upgrade-pilet.ts

@@ -88,6 +88,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     logLevel = upgradePiletDefaults.logLevel,
     install = upgradePiletDefaults.install,
     variables = upgradePiletDefaults.variables,
+    npmClient: defaultNpmClient = upgradePiletDefaults.npmClient,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   const root = resolve(fullBase, target);
@@ -98,7 +99,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     fail('invalidPiletTarget_0040');
   }
 
-  const npmClient = await determineNpmClient(root, options.npmClient);
+  const npmClient = await determineNpmClient(root, defaultNpmClient);
   const pckg = await readJson(root, 'package.json');
   const { devDependencies = {}, dependencies = {}, piral, source } = pckg;
 

package/src/apps/upgrade-piral.ts

@@ -80,6 +80,7 @@ export async function upgradePiral(baseDir = process.cwd(), options: UpgradePira
     target = upgradePiralDefaults.target,
     logLevel = upgradePiralDefaults.logLevel,
     install = upgradePiralDefaults.install,
+    npmClient: defaultNpmClient = upgradePiralDefaults.npmClient,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   const root = resolve(fullBase, target);
@@ -91,7 +92,7 @@ export async function upgradePiral(baseDir = process.cwd(), options: UpgradePira
     fail('packageJsonNotFound_0020');
   }
 
-  const npmClient = await determineNpmClient(root, options.npmClient);
+  const npmClient = await determineNpmClient(root, defaultNpmClient);
 
   progress(`Checking provided version ...`);
   const realVersion = await findSpecificVersion('piral-cli', version);

package/src/commands.ts

@@ -6,9 +6,9 @@ import {
   forceOverwriteKeys,
   keyOfForceOverwrite,
   valueOfForceOverwrite,
-  keyOfPiletLanguage,
-  piletLanguageKeys,
-  valueOfPiletLanguage,
+  keyOfSourceLanguage,
+  sourceLanguageKeys,
+  valueOfSourceLanguage,
   frameworkKeys,
   clientTypeKeys,
   schemaKeys,
@@ -205,9 +205,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .choices('provider', availableReleaseProviders)
         .describe('provider', 'Sets the provider for publishing the release assets.')
         .default('provider', apps.publishPiralDefaults.provider)
-        .option('fields', undefined)
-        .describe('fields', 'Sets additional fields to be included in the feed service request.')
-        .default('fields', apps.publishPiralDefaults.fields)
+        .option('opts', undefined)
+        .describe('opts', 'Sets the options to forward to the chosen provider.')
+        .default('opts', apps.publishPiralDefaults.opts)
         .boolean('interactive')
         .describe('interactive', 'Defines if authorization tokens can be retrieved interactively.')
         .default('interactive', apps.publishPiralDefaults.interactive)
@@ -221,7 +221,7 @@ const allCommands: Array<ToolCommand<any>> = [
         logLevel: args['log-level'] as LogLevels,
         type: args.type as PiralBuildType,
         provider: args.provider as string,
-        fields: args.fields as Record<string, string>,
+        opts: args.opts as Record<string, string>,
         interactive: args.interactive as boolean,
       });
     },
@@ -297,9 +297,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .choices('force-overwrite', forceOverwriteKeys)
         .describe('force-overwrite', 'Determines if files should be overwritten by the installation.')
         .default('force-overwrite', keyOfForceOverwrite(apps.newPiralDefaults.forceOverwrite))
-        .choices('language', piletLanguageKeys)
+        .choices('language', sourceLanguageKeys)
         .describe('language', 'Determines the programming language for the new Piral instance.')
-        .default('language', keyOfPiletLanguage(apps.newPiralDefaults.language))
+        .default('language', keyOfSourceLanguage(apps.newPiralDefaults.language))
         .string('template')
         .describe('template', 'Sets the boilerplate template package to be used when scaffolding.')
         .default('template', apps.newPiralDefaults.template)
@@ -324,7 +324,7 @@ const allCommands: Array<ToolCommand<any>> = [
         version: args.tag as string,
         registry: args.registry as string,
         forceOverwrite: valueOfForceOverwrite(args['force-overwrite'] as string),
-        language: valueOfPiletLanguage(args.language as string),
+        language: valueOfSourceLanguage(args.language as string),
         install: args.install as boolean,
         template: args.template as string,
         logLevel: args['log-level'] as LogLevels,
@@ -682,9 +682,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .number('log-level')
         .describe('log-level', 'Sets the log level to use (1-5).')
         .default('log-level', apps.newPiletDefaults.logLevel)
-        .choices('language', piletLanguageKeys)
+        .choices('language', sourceLanguageKeys)
         .describe('language', 'Determines the programming language for the new pilet.')
-        .default('language', keyOfPiletLanguage(apps.newPiletDefaults.language))
+        .default('language', keyOfSourceLanguage(apps.newPiletDefaults.language))
         .string('template')
         .describe('template', 'Sets the boilerplate template package to be used when scaffolding.')
         .default('template', apps.newPiletDefaults.template)
@@ -707,7 +707,7 @@ const allCommands: Array<ToolCommand<any>> = [
         source: args.source as string,
         registry: args.registry as string,
         forceOverwrite: valueOfForceOverwrite(args['force-overwrite'] as string),
-        language: valueOfPiletLanguage(args.language as string),
+        language: valueOfSourceLanguage(args.language as string),
         logLevel: args['log-level'] as LogLevels,
         install: args.install as boolean,
         template: args.template as string,

package/src/common/clients/index.ts

@@ -1,5 +1,6 @@
 import * as lerna from './lerna';
 import * as npm from './npm';
+import * as pnp from './pnp';
 import * as pnpm from './pnpm';
 import * as rush from './rush';
 import * as yarn from './yarn';
@@ -7,6 +8,7 @@ import * as yarn from './yarn';
 export const clients = {
   lerna,
   npm,
+  pnp,
   pnpm,
   rush,
   yarn,
@@ -14,7 +16,7 @@ export const clients = {
 
 type ClientName = keyof typeof clients;
 
-const directClients = ['npm', 'yarn', 'pnpm'];
+const directClients = ['npm', 'pnp', 'yarn', 'pnpm'];
 
 export function isWrapperClient(client: ClientName) {
   return !directClients.includes(client);

package/src/common/clients/npm.ts

@@ -47,6 +47,10 @@ export async function initProject(projectName: string, target: string) {}
 
 // Functions to exclusively use from npm client:
 
+export async function loginUser() {
+  await runNpmProcess(['login'], '.');
+}
+
 export async function unpackPackage(packageRef: string, target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['pack', packageRef, ...flags], target, ms);

package/src/common/clients/pnp.ts

@@ -0,0 +1,77 @@
+import { resolve } from 'path';
+import { log } from '../log';
+import { findFile } from '../io';
+import { runCommand } from '../scripts';
+import { MemoryStream } from '../MemoryStream';
+
+// Helpers:
+
+function runYarnProcess(args: Array<string>, target: string, output?: NodeJS.WritableStream) {
+  log('generalDebug_0003', 'Starting the Yarn PnP process ...');
+  const cwd = resolve(process.cwd(), target);
+  return runCommand('yarn', args, cwd, output);
+}
+
+function convert(flags: Array<string>) {
+  return flags.map((flag) => {
+    switch (flag) {
+      case '--save-exact':
+        return '--exact';
+      case '--save-dev':
+        return '--dev';
+      case '--no-save':
+        // unfortunately no (https://github.com/yarnpkg/yarn/issues/1743)
+        return '';
+      default:
+        return flag;
+    }
+  });
+}
+
+// Client interface functions:
+
+export async function installDependencies(target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runYarnProcess(['install', ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Yarn PnP install dependencies result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runYarnProcess(['add', packageRef, ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Yarn PnP install package result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function detectClient(root: string) {
+  return !!(await findFile(root, '.pnp.cjs'));
+}
+
+export async function initProject(projectName: string, target: string) {}
+
+export async function isProject(root: string, packageRef: string) {
+  const details = await listProjects(root);
+
+  if (typeof details === 'object') {
+    return typeof details?.[packageRef]?.location === 'string';
+  }
+
+  return false;
+}
+
+// Functions to exclusively use from yarn client:
+
+export async function listProjects(target: string) {
+  const ms = new MemoryStream();
+
+  try {
+    await runYarnProcess(['workspaces', 'info'], target, ms);
+  } catch (e) {
+    log('generalDebug_0003', `yarn workspaces error: ${e}`);
+    return {};
+  }
+
+  log('generalDebug_0003', `yarn workspaces result: ${ms.value}`);
+  return JSON.parse(ms.value);
+}

package/src/common/clients/yarn.ts

@@ -7,7 +7,7 @@ import { MemoryStream } from '../MemoryStream';
 // Helpers:
 
 function runYarnProcess(args: Array<string>, target: string, output?: NodeJS.WritableStream) {
-  log('generalDebug_0003', 'Starting the Yarn@1 process ...');
+  log('generalDebug_0003', 'Starting the Yarn Classic process ...');
   const cwd = resolve(process.cwd(), target);
   return runCommand('yarn', args, cwd, output);
 }
@@ -33,14 +33,14 @@ function convert(flags: Array<string>) {
 export async function installDependencies(target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runYarnProcess(['install', ...convert(flags)], target, ms);
-  log('generalDebug_0003', `Yarn@1 install dependencies result: ${ms.value}`);
+  log('generalDebug_0003', `Yarn Classic install dependencies result: ${ms.value}`);
   return ms.value;
 }
 
 export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runYarnProcess(['add', packageRef, ...convert(flags)], target, ms);
-  log('generalDebug_0003', `Yarn@1 install package result: ${ms.value}`);
+  log('generalDebug_0003', `Yarn Classic install package result: ${ms.value}`);
   return ms.value;
 }
 

package/src/common/http.ts

@@ -57,28 +57,35 @@ export function downloadFile(target: string, ca?: Buffer): Promise<Array<string>
     });
 }
 
-export interface PostFileResult {
+export interface PostFormResult {
   status: number;
   success: boolean;
   response?: object;
 }
 
-export function postFile(
+export type FormDataObj = Record<string, string | [Buffer, string]>;
+
+export function postForm(
   target: string,
   scheme: PiletPublishScheme,
   key: string,
-  file: Buffer,
-  customFields: Record<string, string> = {},
+  formData: FormDataObj,
   customHeaders: Record<string, string> = {},
   ca?: Buffer,
   interactive = false,
-): Promise<PostFileResult> {
-  const form = new FormData();
+): Promise<PostFormResult> {
   const httpsAgent = ca ? new Agent({ ca }) : undefined;
+  const form = new FormData();
 
-  Object.keys(customFields).forEach((key) => form.append(key, customFields[key]));
+  Object.keys(formData).forEach((key) => {
+    const value = formData[key];
 
-  form.append('file', file, 'pilet.tgz');
+    if (typeof value === 'string') {
+      form.append(key, value);
+    } else {
+      form.append(key, value[0], value[1]);
+    }
+  });
 
   const headers: Record<string, string> = {
     ...form.getHeaders(),
@@ -112,11 +119,13 @@ export function postFile(
       maxBodyLength: Infinity,
     })
     .then(
-      (res) => ({
-        status: res.status,
-        success: true,
-        response: res.data,
-      }),
+      (res) => {
+        return {
+          status: res.status,
+          success: true,
+          response: res.data,
+        };
+      },
       (error) => {
         if (error.response) {
           // The request was made and the server responded with a status code
@@ -133,7 +142,7 @@ export function postFile(
               );
 
               return getTokenInteractively(interactiveAuth, httpsAgent).then(({ mode, token }) =>
-                postFile(target, mode, token, file, customFields, customHeaders, ca, false),
+                postForm(target, mode, token, formData, customHeaders, ca, false),
               );
             }
           }
@@ -178,3 +187,17 @@ export function postFile(
       },
     );
 }
+
+export function postFile(
+  target: string,
+  scheme: PiletPublishScheme,
+  key: string,
+  file: Buffer,
+  customFields: Record<string, string> = {},
+  customHeaders: Record<string, string> = {},
+  ca?: Buffer,
+  interactive = false,
+): Promise<PostFormResult> {
+  const data: FormDataObj = { ...customFields, file: [file, 'pilet.tgz'] };
+  return postForm(target, scheme, key, data, customHeaders, ca, interactive);
+}

package/src/common/injectors.ts

@@ -1,25 +1,9 @@
 import chalk from 'chalk';
-import { KrasConfigurationInjectors } from 'kras';
+import { resolve } from 'path';
 import { liveIcon, settingsIcon } from './emoji';
 import { logInfo, log, logReset } from './log';
 import { Bundler } from '../types';
 
-export function reorderInjectors(injectorName: string, injectorConfig: any, injectors: KrasConfigurationInjectors) {
-  return {
-    script: injectors.script || {
-      active: true,
-    },
-    har: injectors.har || {
-      active: true,
-    },
-    json: injectors.json || {
-      active: true,
-    },
-    [injectorName]: injectorConfig,
-    ...injectors,
-  };
-}
-
 export function notifyServerOnline(bundlers: Array<Bundler>, path: string, api: string | false) {
   return (svc: any) => {
     log('generalDebug_0003', `The kras server for debugging is online!`);
@@ -30,3 +14,48 @@ export function notifyServerOnline(bundlers: Array<Bundler>, path: string, api:
     bundlers.forEach((bundler) => bundler.start());
   };
 }
+
+export function createInitialKrasConfig(
+  directory: string,
+  map: Record<string, string> = {},
+  sources: Array<string> = [],
+  feed: string | Array<string> = [],
+) {
+  return {
+    api: '/manage-mock-server',
+    directory,
+    map: {
+      '/': '',
+      ...map,
+    },
+    ssl: undefined,
+    sources,
+    injectorDirs: [resolve(__dirname, '../injectors')],
+    injectors: {
+      script: {
+        active: true,
+      },
+      har: {
+        active: true,
+        delay: false,
+      },
+      json: {
+        active: true,
+        randomize: true,
+      },
+      piral: {
+        active: true,
+        headers: {},
+      },
+      pilet: {
+        active: true,
+        meta: 'debug-meta.json',
+        headers: {},
+        feed,
+      },
+      proxy: {
+        active: true,
+      },
+    },
+  };
+}