piral-cli 1.5.0-beta.6732 → 1.5.0-beta.6744

package/src/common/http.ts

@@ -1,10 +1,12 @@
-import { join } from 'path';
+import { basename, dirname, join } from 'path';
 import { Agent } from 'https';
 import { Stream } from 'stream';
 import { tmpdir } from 'os';
 import { createWriteStream } from 'fs';
 import { log } from './log';
+import { config } from './config';
 import { standardHeaders } from './info';
+import { checkExists, readBinary } from './io';
 import { getTokenInteractively } from './interactive';
 import { axios, FormData } from '../external';
 import { PublishScheme } from '../types';
@@ -37,6 +39,67 @@ function streamToFile(source: Stream, target: string) {
   });
 }
 
+export function getAxiosOptions(url: string) {
+  const auth = config.auth?.[url];
+
+  switch (auth?.mode) {
+    case 'header':
+      return {
+        headers: {
+          [auth.key]: auth.value,
+        },
+      };
+    case 'http':
+      return {
+        auth: {
+          username: auth.username,
+          password: auth.password,
+        },
+      };
+    default:
+      return {};
+  }
+}
+
+export async function getCertificate(cert = config.cert): Promise<Buffer> {
+  log('generalDebug_0003', 'Checking if certificate exists.');
+
+  if (await checkExists(cert)) {
+    const dir = dirname(cert);
+    const file = basename(cert);
+    log('generalDebug_0003', `Reading certificate file "${file}" from "${dir}".`);
+    return await readBinary(dir, file);
+  }
+
+  return undefined;
+}
+
+export function getAuthorizationHeaders(scheme: PublishScheme, key: string) {
+  if (key) {
+    switch (scheme) {
+      case 'basic':
+        return {
+          authorization: `Basic ${key}`,
+        };
+      case 'bearer':
+        return {
+          authorization: `Bearer ${key}`,
+        };
+      case 'digest':
+        return {
+          authorization: `Digest ${key}`,
+        };
+      case 'none':
+      default:
+        return {
+          authorization: key,
+        };
+    }
+  }
+
+  return {};
+}
+
 export function downloadFile(target: string, ca?: Buffer): Promise<Array<string>> {
   const httpsAgent = ca ? new Agent({ ca }) : undefined;
   return axios.default
@@ -57,24 +120,9 @@ export function downloadFile(target: string, ca?: Buffer): Promise<Array<string>
     });
 }
 
-export interface PostFormResult {
-  status: number;
-  success: boolean;
-  response?: object;
-}
-
 export type FormDataObj = Record<string, string | number | boolean | [Buffer, string]>;
 
-export function postForm(
-  target: string,
-  scheme: PublishScheme,
-  key: string,
-  formData: FormDataObj,
-  customHeaders: Record<string, string> = {},
-  ca?: Buffer,
-  interactive = false,
-): Promise<PostFormResult> {
-  const httpsAgent = ca ? new Agent({ ca }) : undefined;
+export function createAxiosForm(formData: FormDataObj) {
   const form = new FormData();
 
   Object.keys(formData).forEach((key) => {
@@ -89,105 +137,126 @@ export function postForm(
     }
   });
 
+  return form;
+}
+
+export function handleAxiosError(
+  error: any,
+  interactive: boolean,
+  httpsAgent: Agent,
+  refetch: (mode: PublishScheme, key: string) => Promise<any>,
+  onfail?: (status: number, statusText: string, response: string) => any,
+) {
+  if (!onfail) {
+    onfail = () => {
+      throw error;
+    };
+  }
+
+  if (error.response) {
+    // The request was made and the server responded with a status code
+    // that falls out of the range of 2xx
+    const { data, statusText, status } = error.response;
+
+    if (interactive && 'interactiveAuth' in data) {
+      const { interactiveAuth } = data;
+
+      if (typeof interactiveAuth === 'string') {
+        log(
+          'generalDebug_0003',
+          `Received status "${status}" from HTTP - trying interactive log in to "${interactiveAuth}".`,
+        );
+
+        return getTokenInteractively(interactiveAuth, httpsAgent).then(({ mode, token }) => refetch(mode, token));
+      }
+    }
+
+    const message = getMessage(data) || '';
+    return onfail(status, statusText, message);
+  } else if (error.isAxiosError) {
+    // axios initiated error: try to parse message from error object
+    let errorMessage: string = error.errno || 'Unknown Axios Error';
+
+    if (typeof error.toJSON === 'function') {
+      const errorObj: { message?: string } = error.toJSON();
+      errorMessage = errorObj?.message ?? errorMessage;
+    }
+
+    return onfail(500, undefined, errorMessage);
+  } else if (error.request) {
+    // The request was made but no response was received
+    // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
+    // http.ClientRequest in node.js
+    return onfail(500, undefined, error.request);
+  } else {
+    // Something happened in setting up the request that triggered an Error
+    return onfail(500, undefined, error.message);
+  }
+}
+
+export interface PostFormResult {
+  status: number;
+  success: boolean;
+  response?: object;
+}
+
+export async function postForm(
+  target: string,
+  scheme: PublishScheme,
+  key: string,
+  formData: FormDataObj,
+  customHeaders: Record<string, string> = {},
+  ca?: Buffer,
+  interactive = false,
+): Promise<PostFormResult> {
+  const httpsAgent = ca ? new Agent({ ca }) : undefined;
+  const form = createAxiosForm(formData);
+
   const headers: Record<string, string> = {
     ...form.getHeaders(),
     ...standardHeaders,
     ...customHeaders,
+    ...getAuthorizationHeaders(scheme, key),
   };
 
-  if (key) {
-    switch (scheme) {
-      case 'basic':
-        headers.authorization = `Basic ${key}`;
-        break;
-      case 'bearer':
-        headers.authorization = `Bearer ${key}`;
-        break;
-      case 'digest':
-        headers.authorization = `Digest ${key}`;
-        break;
-      case 'none':
-      default:
-        headers.authorization = key;
-        break;
-    }
-  }
-
-  return axios.default
-    .post(target, form, {
+  try {
+    const res = await axios.default.post(target, form, {
       headers,
       httpsAgent,
       maxContentLength: Infinity,
       maxBodyLength: Infinity,
-    })
-    .then(
-      (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
-          // that falls out of the range of 2xx
-          const { data, statusText, status } = error.response;
-
-          if (interactive && 'interactiveAuth' in data) {
-            const { interactiveAuth } = data;
-
-            if (typeof interactiveAuth === 'string') {
-              log(
-                'generalDebug_0003',
-                `Received status "${status}" from HTTP - trying interactive log in to "${interactiveAuth}".`,
-              );
-
-              return getTokenInteractively(interactiveAuth, httpsAgent).then(({ mode, token }) =>
-                postForm(target, mode, token, formData, customHeaders, ca, false),
-              );
-            }
-          }
-
-          const message = getMessage(data) || '';
-          log('unsuccessfulHttpPost_0066', statusText, status, message);
-          return {
-            status,
-            success: false,
-            response: message,
-          };
-        } else if (error.isAxiosError) {
-          // axios initiated error: try to parse message from error object
-          let errorMessage: string = error.errno || 'Unknown Axios Error';
-
-          if (typeof error.toJSON === 'function') {
-            const errorObj: { message?: string } = error.toJSON();
-            errorMessage = errorObj?.message ?? errorMessage;
-          }
+    });
 
-          log('failedHttpPost_0065', errorMessage);
+    return {
+      status: res.status,
+      success: true,
+      response: res.data,
+    };
+  } catch (error) {
+    return await handleAxiosError(
+      error,
+      interactive,
+      httpsAgent,
+      (mode, token) => postForm(target, mode, token, formData, customHeaders, ca, false),
+      (status, statusText, response) => {
+        if (status === 500) {
+          log('failedHttpPost_0065', response);
           return {
             status: 500,
             success: false,
-            response: errorMessage,
+            response: undefined,
           };
-        } else if (error.request) {
-          // The request was made but no response was received
-          // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
-          // http.ClientRequest in node.js
-          log('failedHttpPost_0065', error.request);
         } else {
-          // Something happened in setting up the request that triggered an Error
-          log('failedHttpPost_0065', error.message);
+          log('unsuccessfulHttpPost_0066', statusText, status, response);
+          return {
+            status,
+            success: false,
+            response,
+          };
         }
-
-        return {
-          status: 500,
-          success: false,
-          response: undefined,
-        };
       },
     );
+  }
 }
 
 export function postFile(

package/src/common/interactive.ts

@@ -69,10 +69,10 @@ export function getTokenInteractively(url: string, httpsAgent: Agent): TokenResu
 
         try {
           while (true) {
-            const { data, status } = await axios.default.get(callbackUrl);
+            const { data, status } = await axios.default.get(callbackUrl, { httpsAgent, headers: standardHeaders });
 
             if (status === 202) {
-              await new Promise(resolve => setTimeout(resolve, 5000));
+              await new Promise((resolve) => setTimeout(resolve, 5000));
               continue;
             }
 

package/src/common/website.ts

@@ -1,7 +1,9 @@
+import { Agent } from 'https';
 import { join, relative, resolve } from 'path';
 import { createPiralStubIndexIfNotExists } from './template';
-import { config } from './config';
+import { getAuthorizationHeaders, getAxiosOptions, getCertificate, handleAxiosError } from './http';
 import { packageJson } from './constants';
+import { updateConfig } from './config';
 import { ForceOverwrite } from './enums';
 import { createDirectory, readJson, writeBinary } from './io';
 import { writeJson } from './io';
@@ -9,35 +11,43 @@ import { progress, log } from './log';
 import { axios } from '../external';
 import { EmulatorWebsiteManifestFiles, EmulatorWebsiteManifest } from '../types';
 
-function requestManifest(url: string) {
-  const auth = config.auth?.[url];
+async function requestManifest(url: string, httpsAgent?: Agent) {
+  const opts = getAxiosOptions(url);
 
-  switch (auth?.mode) {
-    case 'header':
-      return axios.default.get(url, {
-        headers: {
-          [auth.key]: auth.value,
-        },
-      });
-    case 'http':
-      return axios.default.get(url, {
-        auth: {
-          username: auth.username,
-          password: auth.password,
-        },
-      });
-    default:
-      return axios.default.get(url);
+  try {
+    return await axios.default.get(url, { ...opts, httpsAgent });
+  } catch (error) {
+    return await handleAxiosError(error, true, httpsAgent, async (mode, key) => {
+      const headers = getAuthorizationHeaders(mode, key);
+
+      if (headers.authorization) {
+        await updateConfig('auth', {
+          [url]: {
+            mode: 'header',
+            key: 'authorization',
+            value: headers.authorization,
+          },
+        });
+      }
+
+      return await axios.default.get(url, { headers, httpsAgent });
+    });
   }
 }
 
-async function downloadEmulatorFiles(manifestUrl: string, target: string, files: EmulatorWebsiteManifestFiles) {
+async function downloadEmulatorFiles(
+  manifestUrl: string,
+  target: string,
+  files: EmulatorWebsiteManifestFiles,
+  httpsAgent?: Agent,
+) {
   const requiredFiles = [files.typings, files.main, files.app];
+  const opts = getAxiosOptions(manifestUrl);
 
   await Promise.all(
     requiredFiles.map(async (file) => {
       const url = new URL(file, manifestUrl);
-      const res = await axios.default.get(url.href, { responseType: 'arraybuffer' });
+      const res = await axios.default.get(url.href, { ...opts, httpsAgent, responseType: 'arraybuffer' });
       const data: Buffer = res.data;
       await writeBinary(target, file, data);
     }),
@@ -49,6 +59,7 @@ async function createEmulatorFiles(
   appDir: string,
   manifestUrl: string,
   emulatorJson: EmulatorWebsiteManifest,
+  httpsAgent?: Agent,
 ) {
   const mainFile = 'index.js';
   const appDirName = relative(targetDir, appDir);
@@ -85,14 +96,16 @@ async function createEmulatorFiles(
     outFile: emulatorJson.files.main,
   });
 
-  await downloadEmulatorFiles(manifestUrl, appDir, emulatorJson.files);
+  await downloadEmulatorFiles(manifestUrl, appDir, emulatorJson.files, httpsAgent);
 }
 
 export async function updateFromEmulatorWebsite(targetDir: string, manifestUrl: string) {
   progress(`Updating emulator from %s ...`, manifestUrl);
+  const ca = await getCertificate();
+  const httpsAgent = ca ? new Agent({ ca }) : undefined;
 
   try {
-    const response = await requestManifest(manifestUrl);
+    const response = await requestManifest(manifestUrl, httpsAgent);
     const nextEmulator: EmulatorWebsiteManifest = response.data;
     const currentEmulator = await readJson(targetDir, packageJson);
 
@@ -101,7 +114,7 @@ export async function updateFromEmulatorWebsite(targetDir: string, manifestUrl:
     } else if (currentEmulator.piralCLI.timstamp !== nextEmulator.timestamp) {
       log('generalDebug_0003', `The timestamp on "${currentEmulator.name}" is different (${nextEmulator.timestamp}).`);
       const appDir = resolve(targetDir, 'app');
-      await createEmulatorFiles(targetDir, appDir, manifestUrl, nextEmulator);
+      await createEmulatorFiles(targetDir, appDir, manifestUrl, nextEmulator, httpsAgent);
     } else {
       log('generalDebug_0003', `Nothing to update for "${currentEmulator.name}".`);
     }
@@ -113,11 +126,13 @@ export async function updateFromEmulatorWebsite(targetDir: string, manifestUrl:
 
 export async function scaffoldFromEmulatorWebsite(rootDir: string, manifestUrl: string) {
   progress(`Downloading emulator from %s ...`, manifestUrl);
-  const response = await requestManifest(manifestUrl);
+  const ca = await getCertificate();
+  const httpsAgent = ca ? new Agent({ ca }) : undefined;
+  const response = await requestManifest(manifestUrl, httpsAgent);
   const emulatorJson: EmulatorWebsiteManifest = response.data;
   const targetDir = resolve(rootDir, 'node_modules', emulatorJson.name);
   const appDir = resolve(targetDir, 'app');
   await createDirectory(appDir);
-  await createEmulatorFiles(targetDir, appDir, manifestUrl, emulatorJson);
+  await createEmulatorFiles(targetDir, appDir, manifestUrl, emulatorJson, httpsAgent);
   return { name: emulatorJson.name, path: targetDir };
 }

package/src/injectors/pilet-injector.ts

@@ -5,6 +5,7 @@ import { existsSync } from 'fs';
 import { readFile, stat, writeFile } from 'fs/promises';
 import { KrasInjector, KrasRequest, KrasInjectorConfig, KrasConfiguration, KrasResult } from 'kras';
 import { log } from '../common/log';
+import { getAxiosOptions } from '../common/http';
 import { getPiletSpecMeta } from '../common/spec';
 import { config as commonConfig } from '../common/config';
 import { axios, mime, jju } from '../external';
@@ -146,7 +147,7 @@ export default class PiletInjector implements KrasInjector {
         if (existsSync(path)) {
           try {
             const packageJson = require(path);
-  
+
             if (typeof packageJson.piralCLI.source === 'string') {
               this.proxyInfo = {
                 source: packageJson.piralCLI.source,
@@ -343,28 +344,10 @@ export default class PiletInjector implements KrasInjector {
   }
 
   private download(path: string) {
-    const url = new URL(path, this.proxyInfo.source);
-    const auth = commonConfig.auth?.[this.proxyInfo.source];
-
-    switch (auth?.mode) {
-      case 'header':
-        return axios.default.get(url.href, {
-          responseType: 'arraybuffer',
-          headers: {
-            [auth.key]: auth.value,
-          },
-        });
-      case 'http':
-        return axios.default.get(url.href, {
-          responseType: 'arraybuffer',
-          auth: {
-            username: auth.username,
-            password: auth.password,
-          },
-        });
-      default:
-        return axios.default.get(url.href, { responseType: 'arraybuffer' });
-    }
+    const manifestUrl = this.proxyInfo.source;
+    const url = new URL(path, manifestUrl);
+    const opts = getAxiosOptions(manifestUrl);
+    return axios.default.get(url.href, { ...opts, responseType: 'arraybuffer' });
   }
 
   private async shouldLoad(target: string, path: string) {