piral-cli 1.8.0-beta.7544 → 1.8.0-beta.7655

package/src/commands.ts

@@ -218,6 +218,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .string('ca-cert')
         .describe('ca-cert', 'Sets a custom certificate authority to use, if any.')
         .default('ca-cert', apps.publishPiralDefaults.cert)
+        .boolean('allow-self-signed')
+        .describe('allow-self-signed', 'Indicates that self-signed certificates should be allowed.')
+        .default('allow-self-signed', apps.publishPiralDefaults.allowSelfSigned)
         .number('log-level')
         .describe('log-level', 'Sets the log level to use (1-5).')
         .default('log-level', apps.publishPiralDefaults.logLevel)
@@ -250,6 +253,7 @@ const allCommands: Array<ToolCommand<any>> = [
         logLevel: args['log-level'] as LogLevels,
         apiKey: args['api-key'] as string,
         cert: args['ca-cert'] as string,
+        allowSelfSigned: args['allow-self-signed'] as boolean,
         url: args.url as string,
         interactive: args.interactive as boolean,
         mode: args.mode as PublishScheme,
@@ -687,6 +691,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .boolean('interactive')
         .describe('interactive', 'Defines if authorization tokens can be retrieved interactively.')
         .default('interactive', apps.publishPiletDefaults.interactive)
+        .boolean('allow-self-signed')
+        .describe('allow-self-signed', 'Indicates that self-signed certificates should be allowed.')
+        .default('allow-self-signed', apps.publishPiletDefaults.allowSelfSigned)
         .string('base')
         .default('base', process.cwd())
         .describe('base', 'Sets the base directory. By default the current directory is used.');
@@ -698,6 +705,7 @@ const allCommands: Array<ToolCommand<any>> = [
         url: args.url as string,
         logLevel: args['log-level'] as LogLevels,
         cert: args['ca-cert'] as string,
+        allowSelfSigned: args['allow-self-signed'] as boolean,
         bundlerName: args.bundler as string,
         fresh: args.fresh as boolean,
         from: args.from as PiletPublishSource,
@@ -787,6 +795,12 @@ const allCommands: Array<ToolCommand<any>> = [
         .choices('bundler', bundlerKeys)
         .describe('bundler', 'Sets the default bundler to install.')
         .default('bundler', apps.newPiletDefaults.bundlerName)
+        .string('ca-cert')
+        .describe('ca-cert', 'Sets a custom certificate authority to use, if any.')
+        .default('ca-cert', apps.newPiletDefaults.cert)
+        .boolean('allow-self-signed')
+        .describe('allow-self-signed', 'Indicates that self-signed certificates should be allowed.')
+        .default('allow-self-signed', apps.newPiletDefaults.allowSelfSigned)
         .option('vars', undefined)
         .describe('vars', 'Sets additional variables to be used when scaffolding.')
         .default('vars', apps.newPiletDefaults.variables)
@@ -811,6 +825,8 @@ const allCommands: Array<ToolCommand<any>> = [
         bundlerName: args.bundler as string,
         variables: args.vars as Record<string, string>,
         name: args['name'] as string,
+        cert: args['ca-cert'] as string,
+        allowSelfSigned: args['allow-self-signed'] as boolean,
       });
     },
   },
@@ -819,7 +835,7 @@ const allCommands: Array<ToolCommand<any>> = [
     alias: ['upgrade'],
     description: 'Upgrades an existing pilet to the latest version of the used Piral instance.',
     arguments: ['[target-version]'],
-    flags(argv) {
+    flags(argv: any) {
       return argv
         .positional('target-version', {
           type: 'string',
@@ -842,6 +858,12 @@ const allCommands: Array<ToolCommand<any>> = [
         .choices('npm-client', clientTypeKeys)
         .describe('npm-client', 'Sets the npm client to be used when upgrading.')
         .default('npm-client', apps.upgradePiletDefaults.npmClient)
+        .string('ca-cert')
+        .describe('ca-cert', 'Sets a custom certificate authority to use, if any.')
+        .default('ca-cert', apps.upgradePiletDefaults.cert)
+        .boolean('allow-self-signed')
+        .describe('allow-self-signed', 'Indicates that self-signed certificates should be allowed.')
+        .default('allow-self-signed', apps.upgradePiletDefaults.allowSelfSigned)
         .option('vars', undefined)
         .describe('vars', 'Sets additional variables to be used when scaffolding.')
         .default('vars', apps.upgradePiletDefaults.variables)
@@ -858,6 +880,8 @@ const allCommands: Array<ToolCommand<any>> = [
         install: args.install as boolean,
         npmClient: args['npm-client'] as NpmClientType,
         variables: args.vars as Record<string, string>,
+        cert: args['ca-cert'] as string,
+        allowSelfSigned: args['allow-self-signed'] as boolean,
       });
     },
   },
@@ -916,6 +940,12 @@ const allCommands: Array<ToolCommand<any>> = [
         .boolean('selected')
         .describe('selected', 'Defines if the provided Piral instance should be selected initially.')
         .default('selected', apps.addPiralInstancePiletDefaults.selected)
+        .string('ca-cert')
+        .describe('ca-cert', 'Sets a custom certificate authority to use, if any.')
+        .default('ca-cert', apps.addPiralInstancePiletDefaults.cert)
+        .boolean('allow-self-signed')
+        .describe('allow-self-signed', 'Indicates that self-signed certificates should be allowed.')
+        .default('allow-self-signed', apps.addPiralInstancePiletDefaults.allowSelfSigned)
         .string('base')
         .default('base', process.cwd())
         .describe('base', 'Sets the base directory. By default the current directory is used.');
@@ -927,6 +957,8 @@ const allCommands: Array<ToolCommand<any>> = [
         npmClient: args['npm-client'] as NpmClientType,
         app: args.app as string,
         source: args.source as string,
+        cert: args['ca-cert'] as string,
+        allowSelfSigned: args['allow-self-signed'] as boolean,
       });
     },
   },
@@ -995,6 +1027,12 @@ const allCommands: Array<ToolCommand<any>> = [
         .choices('npm-client', clientTypeKeys)
         .describe('npm-client', 'Sets the npm client to be used when installing the emulator.')
         .default('npm-client', apps.runEmulatorPiralDefaults.npmClient)
+        .string('ca-cert')
+        .describe('ca-cert', 'Sets a custom certificate authority to use, if any.')
+        .default('ca-cert', apps.runEmulatorPiralDefaults.cert)
+        .boolean('allow-self-signed')
+        .describe('allow-self-signed', 'Indicates that self-signed certificates should be allowed.')
+        .default('allow-self-signed', apps.runEmulatorPiralDefaults.allowSelfSigned)
         .boolean('open')
         .describe('open', 'Opens the Piral instance directly in the browser.')
         .default('open', apps.runEmulatorPiralDefaults.open)
@@ -1014,6 +1052,8 @@ const allCommands: Array<ToolCommand<any>> = [
         logLevel: args['log-level'] as LogLevels,
         open: args.open as boolean,
         feed: args.feed as string,
+        cert: args['ca-cert'] as string,
+        allowSelfSigned: args['allow-self-signed'] as boolean,
       });
     },
   },

package/src/common/config.ts

@@ -73,6 +73,10 @@ export interface PiralCliConfig {
    * Npm registry.
    */
   registry?: string;
+  /**
+   * Allow self-signed certificates.
+   */
+  allowSelfSigned?: boolean;
 }
 
 export const config: PiralCliConfig = rc(
@@ -89,6 +93,7 @@ export const config: PiralCliConfig = rc(
     validators: {},
     schemaVersion: 'v2' as const,
     openBrowser: false,
+    allowSelfSigned: false,
     port: 1234,
     strictPort: false,
     language: 'ts' as const,

package/src/common/constants.ts

@@ -29,6 +29,7 @@ export const bundlerNames = [
   'webpack5' as const,
   'vite' as const,
   'vite5' as const,
+  'vite6' as const,
   'xbuild' as const,
 ];
 export const declarationEntryExtensions = ['.html', '.pug', ...entryModuleExtensions];

package/src/common/emulator.ts

@@ -1,4 +1,4 @@
-import { join, resolve, relative, basename, extname } from 'path';
+import { join, resolve, relative, basename, posix } from 'path';
 import { findDependencyVersion, copyScaffoldingFiles, isValidDependency, flattenExternals } from './package';
 import { createPiralStubIndexIfNotExists } from './template';
 import { filesTar, filesOnceTar, packageJson, piralJson, emulatorJson } from './constants';
@@ -139,9 +139,9 @@ export async function createEmulatorSources(
       version: cliVersion,
       generated: true,
     },
-    main: `./${join(appDir, 'index.js')}`,
-    typings: `./${join(appDir, 'index.d.ts')}`,
-    app: `./${join(appDir, 'index.html')}`,
+    main: `./${posix.join(appDir, 'index.js')}`,
+    typings: `./${posix.join(appDir, 'index.d.ts')}`,
+    app: `./${posix.join(appDir, 'index.html')}`,
     peerDependencies: {},
     optionalDependencies,
     devDependencies: {

package/src/common/http.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vitest } from 'vitest';
-import { postFile, downloadFile } from './http';
+import { postFile, downloadFile, getAgent } from './http';
 
 const apiUrl = 'http://sample.fooo.com/api/v1/pilet';
 
@@ -80,7 +80,7 @@ vitest.mock('../external', async () => {
         },
       },
     },
-    FormData: (await vitest.importActual('form-data') as any).default,
+    FormData: ((await vitest.importActual('form-data')) as any).default,
   };
 });
 
@@ -155,10 +155,11 @@ describe('HTTP Module', () => {
 
   it('downloadFile calls results in error', async () => {
     errorOther = true;
-    let result = await downloadFile('http://sample.com/', Buffer.from('example'));
+    const agent = getAgent({ ca: Buffer.from('example') });
+    let result = await downloadFile('http://sample.com/', agent);
     expect(result.length).toBe(0);
     errorOther = false;
-    result = await downloadFile('http://sample.com/', Buffer.from('example'));
+    result = await downloadFile('http://sample.com/', agent);
     expect(result.length).toBe(0);
   });
 });

package/src/common/http.ts

@@ -100,8 +100,28 @@ export function getAuthorizationHeaders(scheme: PublishScheme, key: string) {
   return {};
 }
 
-export function downloadFile(target: string, ca?: Buffer): Promise<Array<string>> {
-  const httpsAgent = ca ? new Agent({ ca }) : undefined;
+export interface AgentOptions {
+  ca?: Buffer;
+  allowSelfSigned?: boolean;
+}
+
+export async function getDefaultAgent() {
+  const ca = await getCertificate();
+  const allowSelfSigned = config.allowSelfSigned;
+  return getAgent({ ca, allowSelfSigned });
+}
+
+export function getAgent({ allowSelfSigned, ca }: AgentOptions) {
+  if (ca) {
+    return new Agent({ ca });
+  } else if (allowSelfSigned) {
+    return new Agent({ rejectUnauthorized: false });
+  } else {
+    return undefined;
+  }
+}
+
+export function downloadFile(target: string, httpsAgent: Agent): Promise<Array<string>> {
   return axios.default
     .get<Stream>(target, {
       responseType: 'stream',
@@ -206,10 +226,9 @@ export async function postForm(
   key: string,
   formData: FormDataObj,
   customHeaders: Record<string, string> = {},
-  ca?: Buffer,
+  httpsAgent?: Agent,
   interactive = false,
 ): Promise<PostFormResult> {
-  const httpsAgent = ca ? new Agent({ ca }) : undefined;
   const form = createAxiosForm(formData);
 
   const headers: Record<string, string> = {
@@ -237,7 +256,7 @@ export async function postForm(
       error,
       interactive,
       httpsAgent,
-      (mode, token) => postForm(target, mode, token, formData, customHeaders, ca, false),
+      (mode, token) => postForm(target, mode, token, formData, customHeaders, httpsAgent, false),
       (status, statusText, response) => {
         if (status === 500) {
           log('failedHttpPost_0065', response);
@@ -266,9 +285,9 @@ export function postFile(
   file: Buffer,
   customFields: Record<string, string> = {},
   customHeaders: Record<string, string> = {},
-  ca?: Buffer,
+  agent?: Agent,
   interactive = false,
 ): Promise<PostFormResult> {
   const data: FormDataObj = { ...customFields, file: [file, 'pilet.tgz'] };
-  return postForm(target, scheme, key, data, customHeaders, ca, interactive);
+  return postForm(target, scheme, key, data, customHeaders, agent, interactive);
 }

package/src/common/npm.test.ts

@@ -202,39 +202,39 @@ describe('npm Module', () => {
 
   it('installs a package using the npm command line tool without a target', async () => {
     wrongCase = false;
-    await installNpmPackage('npm', 'foo', 'latest').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage({ direct: 'npm' }, 'foo', 'latest').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installNpmPackage('npm', 'foo', 'latest').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage({ direct: 'npm' }, 'foo', 'latest').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the npm command line tool without a version', async () => {
     wrongCase = false;
-    await installNpmPackage('npm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage({ direct: 'npm' }, 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installNpmPackage('npm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage({ direct: 'npm' }, 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the Yarn command line tool without a version', async () => {
     wrongCase = false;
-    await installNpmPackage('yarn', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage({ direct: 'yarn' }, 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installNpmPackage('yarn', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage({ direct: 'yarn' }, 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the Pnpm command line tool without a version', async () => {
     wrongCase = false;
-    await installNpmPackage('pnpm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage({ direct: 'pnpm' }, 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installNpmPackage('pnpm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage({ direct: 'pnpm' }, 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the npm command line tool with some flag', async () => {
     wrongCase = false;
-    await installNpmPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
+    await installNpmPackage({ direct: 'pnpm' }, 'foo', '1.3', '.', '--a=b').then((result) =>
       expect(result).toEqual(jsonValueString),
     );
     wrongCase = true;
-    await installNpmPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
+    await installNpmPackage({ direct: 'pnpm' }, 'foo', '1.3', '.', '--a=b').then((result) =>
       expect(result).not.toEqual(jsonValueString),
     );
   });
@@ -281,23 +281,23 @@ describe('npm Module', () => {
 
   it('install dependencies with npm client', async () => {
     wrongCase = false;
-    await installNpmDependencies('npm').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies({ direct: 'npm' }).then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installNpmDependencies('npm').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies({ direct: 'npm' }).then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with pnpm client', async () => {
     wrongCase = false;
-    await installNpmDependencies('pnpm').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies({ direct: 'pnpm' }).then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installNpmDependencies('pnpm').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies({ direct: 'pnpm' }).then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with yarn client', async () => {
     wrongCase = false;
-    await installNpmDependencies('yarn').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies({ direct: 'yarn' }).then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installNpmDependencies('yarn').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies({ direct: 'yarn' }).then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('create npm package', async () => {

package/src/common/npm.ts

@@ -5,10 +5,10 @@ import { config } from './config';
 import { legacyCoreExternals, frameworkLibs, defaultRegistry, packageJson } from './constants';
 import { inspectPackage } from './inspect';
 import { readJson, checkExists } from './io';
-import { clients, detectClients, isWrapperClient } from '../npm-clients';
+import { clients, detectDirectClients, detectWrapperClients, isDirectClient, isWrapperClient } from '../npm-clients';
 import { clientTypeKeys } from '../helpers';
 import { getModulePath } from '../external';
-import { PackageType, NpmClientType } from '../types';
+import { PackageType, NpmClientType, NpmClient, NpmDirectClientType, NpmWapperClientType } from '../types';
 
 const gitPrefix = 'git+';
 const filePrefix = 'file:';
@@ -63,56 +63,88 @@ async function detectMonorepoRoot(root: string): Promise<[] | [string, NpmClient
   return [];
 }
 
-/**
- * For details about how this works consult issue
- * https://github.com/smapiot/piral/issues/203
- * @param root The project's root directory.
- */
-export async function determineNpmClient(root: string, selected?: NpmClientType): Promise<NpmClientType> {
-  if (!selected || !clientTypeKeys.includes(selected)) {
-    log('generalDebug_0003', 'No npm client selected. Checking for lock or config files ...');
+async function determineWrapperClient(root: string): Promise<NpmWapperClientType | undefined> {
+  const searchedClients = await detectWrapperClients(root);
+  const foundClients = searchedClients.filter((m) => m.result).map((m) => m.client);
 
-    const searchedClients = await detectClients(root);
-    const foundClients = searchedClients.filter((m) => m.result);
-
-    log(
-      'generalDebug_0003',
-      `Results of the lock file check: ${searchedClients.map((m) => `${m.client}=${m.result}`).join(', ')}`,
-    );
+  if (foundClients.length > 0) {
+    const [client] = foundClients;
 
     if (foundClients.length > 1) {
-      const wrapperClient = foundClients.find((m) => isWrapperClient(m.client));
-
-      if (wrapperClient) {
-        const { client } = wrapperClient;
-        log('generalDebug_0003', `Found valid wrapper client via lock or config file: "${client}".`);
-      }
+      log(
+        'generalWarning_0001',
+        `Found multiple clients via their lock or config files: "${foundClients.join('", "')}".`,
+      );
     }
 
-    if (foundClients.length > 0) {
-      const { client } = foundClients[0];
+    log('generalDebug_0003', `Found valid direct client via lock or config file: "${client}".`);
+    return client;
+  }
 
-      if (foundClients.length > 1) {
-        const clientStr = `"${foundClients.map((m) => m.client).join('", "')}"`;
-        log('generalWarning_0001', `Found multiple clients via their lock or config files: ${clientStr}.`);
-      }
+  const defaultClient = config.npmClient;
 
-      log('generalDebug_0003', `Found valid direct client via lock or config file: "${client}".`);
-      return client;
-    }
+  if (isWrapperClient(defaultClient)) {
+    log('generalDebug_0003', `Using the default client: "${defaultClient}".`);
+    return defaultClient;
+  }
+
+  return undefined;
+}
 
-    const defaultClient = config.npmClient;
+async function determineDirectClient(root: string): Promise<NpmDirectClientType> {
+  const searchedClients = await detectDirectClients(root);
+  const foundClients = searchedClients.filter((m) => m.result).map((m) => m.client);
 
-    if (clientTypeKeys.includes(defaultClient)) {
-      log('generalDebug_0003', `Using the default client: "${defaultClient}".`);
-      return defaultClient;
+  if (foundClients.length > 0) {
+    const [client] = foundClients;
+
+    if (foundClients.length > 1) {
+      log(
+        'generalWarning_0001',
+        `Found multiple clients via their lock or config files: "${foundClients.join('", "')}".`,
+      );
     }
 
-    log('generalDebug_0003', 'Using the fallback "npm" client.');
-    return 'npm';
+    log('generalDebug_0003', `Found valid direct client via lock or config file: "${client}".`);
+    return client;
+  }
+
+  const defaultClient = config.npmClient;
+
+  if (isDirectClient(defaultClient)) {
+    log('generalDebug_0003', `Using the default client: "${defaultClient}".`);
+    return defaultClient;
   }
 
-  return selected;
+  log('generalDebug_0003', 'Using the fallback "npm" client.');
+  return 'npm';
+}
+
+/**
+ * For details about how this works consult issue
+ * https://github.com/smapiot/piral/issues/203
+ * @param root The project's root directory.
+ */
+export async function determineNpmClient(root: string, selected?: NpmClientType): Promise<NpmClient> {
+  if (!selected || !clientTypeKeys.includes(selected)) {
+    log('generalDebug_0003', 'No npm client selected. Checking for lock or config files ...');
+    const [direct, wrapper] = await Promise.all([determineDirectClient(root), determineWrapperClient(root)]);
+    return {
+      direct,
+      wrapper,
+    };
+  } else if (isDirectClient(selected)) {
+    return {
+      proposed: selected,
+      direct: selected,
+    };
+  } else {
+    return {
+      proposed: selected,
+      direct: await determineDirectClient(root),
+      wrapper: selected,
+    };
+  }
 }
 
 export async function isMonorepoPackageRef(refName: string, root: string): Promise<boolean> {
@@ -126,35 +158,37 @@ export async function isMonorepoPackageRef(refName: string, root: string): Promi
   return false;
 }
 
-export function installNpmDependencies(client: NpmClientType, target = '.'): Promise<string> {
-  const { installDependencies } = clients[client];
+export function installNpmDependencies(client: NpmClient, target = '.'): Promise<string> {
+  const { installDependencies } = clients[client.direct];
   return installDependencies(target);
 }
 
 export async function installNpmPackageFromOptionalRegistry(
   packageRef: string,
-  target = '.',
+  target: string,
   registry: string,
 ): Promise<void> {
+  const client = await determineNpmClient(target, 'npm');
+
   try {
-    await installNpmPackage('npm', packageRef, target, '--registry', registry);
+    await installNpmPackage(client, packageRef, target, '--registry', registry);
   } catch (e) {
     if (registry === defaultRegistry) {
       throw e;
     }
 
-    await installNpmPackage('npm', packageRef, target, '--registry', defaultRegistry);
+    await installNpmPackage(client, packageRef, target, '--registry', defaultRegistry);
   }
 }
 
 export async function uninstallNpmPackage(
-  client: NpmClientType,
+  client: NpmClient,
   packageRef: string,
   target = '.',
   ...flags: Array<string>
 ): Promise<string> {
   try {
-    const { uninstallPackage } = clients[client];
+    const { uninstallPackage } = clients[client.direct];
     return await uninstallPackage(packageRef, target, ...flags);
   } catch (ex) {
     log(
@@ -166,13 +200,13 @@ export async function uninstallNpmPackage(
 }
 
 export async function installNpmPackage(
-  client: NpmClientType,
+  client: NpmClient,
   packageRef: string,
   target = '.',
   ...flags: Array<string>
 ): Promise<string> {
   try {
-    const { installPackage } = clients[client];
+    const { installPackage } = clients[client.direct];
     return await installPackage(packageRef, target, ...flags);
   } catch (ex) {
     log(
@@ -183,8 +217,8 @@ export async function installNpmPackage(
   }
 }
 
-export function initNpmProject(client: NpmClientType, projectName: string, target: string) {
-  const { initProject } = clients[client];
+export function initNpmProject(client: NpmClient, projectName: string, target: string) {
+  const { initProject } = clients[client.wrapper || client.direct];
   return initProject(projectName, target);
 }
 

package/src/common/package.ts

@@ -1,3 +1,4 @@
+import { Agent } from 'https';
 import { resolve, join, extname, basename, dirname, relative } from 'path';
 import { log, fail } from './log';
 import { cliVersion } from './info';
@@ -161,7 +162,8 @@ async function loadPiralInstance(root: string, details?: PiralInstanceDetails):
 export async function findPiralInstance(
   proposedApp: string,
   rootDir: string,
-  details?: PiralInstanceDetails,
+  details: PiralInstanceDetails,
+  agent: Agent,
   interactive = false,
 ) {
   const path = findPackageRoot(proposedApp, rootDir);
@@ -172,13 +174,13 @@ export async function findPiralInstance(
 
     if (url) {
       log('generalDebug_0003', `Updating the emulator from remote "${url}" ...`);
-      await updateFromEmulatorWebsite(root, url, interactive);
+      await updateFromEmulatorWebsite(root, url, agent, interactive);
     }
 
     return await loadPiralInstance(root, details);
   } else if (url) {
     log('generalDebug_0003', `Piral instance not installed yet - trying from remote "${url}" ...`);
-    const emulator = await scaffoldFromEmulatorWebsite(rootDir, url);
+    const emulator = await scaffoldFromEmulatorWebsite(rootDir, url, agent);
     return await loadPiralInstance(emulator.path, details);
   }
 
@@ -190,6 +192,7 @@ export async function findPiralInstances(
   piletPackage: PiletPackageData,
   piletDefinition: undefined | PiletDefinition,
   rootDir: string,
+  agent: Agent,
   interactive?: boolean,
 ) {
   if (proposedApps) {
@@ -208,7 +211,7 @@ export async function findPiralInstances(
   if (proposedApps.length > 0) {
     return Promise.all(
       proposedApps.map((proposedApp) =>
-        findPiralInstance(proposedApp, rootDir, piletDefinition?.piralInstances?.[proposedApp], interactive),
+        findPiralInstance(proposedApp, rootDir, piletDefinition?.piralInstances?.[proposedApp], agent, interactive),
       ),
     );
   }
@@ -280,11 +283,7 @@ export async function getPiralPackage(app: string, data: PiralInstanceData, vers
   };
 }
 
-async function getAvailableFiles(
-  root: string,
-  name: string,
-  dirName: string,
-): Promise<Array<FileDescriptor>> {
+async function getAvailableFiles(root: string, name: string, dirName: string): Promise<Array<FileDescriptor>> {
   const source = getPiralPath(root, name);
   const tgz = `${dirName}.tar`;
   log('generalDebug_0003', `Checking if "${tgz}" exists in "${source}" ...`);
@@ -780,13 +779,13 @@ export async function findPiletRoot(proposedRoot: string) {
   return dirname(packageJsonPath);
 }
 
-export async function retrievePiletData(target: string, app?: string, interactive?: boolean) {
+export async function retrievePiletData(target: string, app?: string, agent?: Agent, interactive?: boolean) {
   const piletJsonPath = await findFile(target, piletJson);
   const proposedRoot = piletJsonPath ? dirname(piletJsonPath) : target;
   const root = await findPiletRoot(proposedRoot);
   const piletPackage = await readJson(root, packageJson);
   const piletDefinition: PiletDefinition = piletJsonPath && (await readJson(proposedRoot, piletJson));
-  const appPackages = await findPiralInstances(app && [app], piletPackage, piletDefinition, root, interactive);
+  const appPackages = await findPiralInstances(app && [app], piletPackage, piletDefinition, root, agent, interactive);
   const apps: Array<AppDefinition> = [];
 
   for (const appPackage of appPackages) {

package/src/common/release.ts

@@ -1,3 +1,4 @@
+import { Agent } from 'https';
 import { basename, dirname, relative } from 'path';
 import { readBinary } from './io';
 import { publishNpmPackage } from './npm';
@@ -39,7 +40,7 @@ export async function publishWebsiteEmulator(
   files: Array<string>,
   interactive: boolean,
   headers?: Record<string, string>,
-  ca?: Buffer,
+  agent?: Agent,
 ) {
   const data: FormDataObj = {
     version,
@@ -53,5 +54,5 @@ export async function publishWebsiteEmulator(
     data[relPath] = [content, fileName];
   }
 
-  return await postForm(url, mode, apiKey, data, headers, ca, interactive);
+  return await postForm(url, mode, apiKey, data, headers, agent, interactive);
 }