piral-cli 0.14.28 → 0.14.31

package/src/common/http.ts

@@ -1,17 +1,14 @@
 import { join } from 'path';
 import { Agent } from 'https';
 import { Stream } from 'stream';
-import { platform, tmpdir } from 'os';
+import { tmpdir } from 'os';
 import { createWriteStream } from 'fs';
 import { log } from './log';
+import { standardHeaders } from './info';
+import { getTokenInteractively } from './interactive';
 import { axios, FormData } from '../external';
 import { PiletPublishScheme } from '../types';
 
-const os = platform();
-const standardHeaders = {
-  'user-agent': `piral-cli/http.node-${os}`,
-};
-
 function getMessage(body: string | { message?: string }) {
   if (typeof body === 'string') {
     try {
@@ -60,27 +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,
-): Promise<PostFileResult> {
-  const form = new FormData();
+  interactive = false,
+): 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(),
@@ -114,16 +119,34 @@ 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
           // 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 {
@@ -164,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/info.ts

@@ -1,6 +1,7 @@
-import { cpus } from 'os';
+import { cpus, platform } from 'os';
 
 const info = require('../../package.json');
+const os = platform();
 
 export function findCompatVersion(version: string) {
   // we only care about major and minor
@@ -22,3 +23,6 @@ export const repositoryUrl = info.repository.url;
 export const isWindows = process.platform === 'win32';
 export const pathSeparator = isWindows ? ';' : ':';
 export const cpuCount = cpus().length;
+export const standardHeaders = {
+  'user-agent': `piral-cli/http.node-${os}`,
+};

package/src/common/injectors.ts

@@ -17,8 +17,8 @@ export function notifyServerOnline(bundlers: Array<Bundler>, path: string, api:
 
 export function createInitialKrasConfig(
   directory: string,
-  map: Record<string, string> = {},
   sources: Array<string> = [],
+  map: Record<string, string> = {},
   feed: string | Array<string> = [],
 ) {
   return {

package/src/common/interactive.test.ts

@@ -3,6 +3,9 @@ import { promptConfirm, promptSelect } from './interactive';
 const answer = 'Yes, really';
 
 jest.mock('../external', () => ({
+  rc(_, cfg) {
+    return cfg;
+  },
   inquirer: {
     prompt: (...any) => {
       return Promise.resolve({ q: answer });

package/src/common/interactive.ts

@@ -1,4 +1,9 @@
-import { inquirer } from '../external';
+import { Agent } from 'https';
+import { openBrowserAt } from './browser';
+import { standardHeaders } from './info';
+import { logSuspend } from './log';
+import { axios, inquirer } from '../external';
+import { PiletPublishScheme } from '../types';
 
 export function promptSelect(message: string, values: Array<string>, defaultValue: string): Promise<string> {
   const questions = [
@@ -24,3 +29,50 @@ export function promptConfirm(message: string, defaultValue: boolean): Promise<b
   ];
   return inquirer.prompt(questions).then((answers: any) => answers.q);
 }
+
+type TokenResult = Promise<{ mode: PiletPublishScheme; token: string }>;
+
+const tokenRetrievers: Record<string, TokenResult> = {};
+
+export function getTokenInteractively(url: string, httpsAgent: Agent): TokenResult {
+  if (!(url in tokenRetrievers)) {
+    const logResume = logSuspend();
+
+    tokenRetrievers[url] = axios.default
+      .post(
+        url,
+        {
+          clientId: 'piral-cli',
+          clientName: 'Piral CLI',
+          description: 'Authorize the Piral CLI temporarily to perform actions in your name.',
+        },
+        {
+          headers: {
+            ...standardHeaders,
+            'content-type': 'application/json',
+          },
+          httpsAgent,
+        },
+      )
+      .then((res) => {
+        const { loginUrl, callbackUrl, expires } = res.data;
+        const now = new Date();
+        const then = new Date(expires);
+        const diff = ~~((then.valueOf() - now.valueOf()) / (60 * 1000));
+
+        console.log(`Use the URL below to complete the login. The link expires in ${diff} minutes (${then}).`);
+        console.log('===');
+        console.log(loginUrl);
+        console.log('===');
+
+        openBrowserAt(loginUrl);
+
+        return axios.default
+          .get(callbackUrl)
+          .then(({ data }) => ({ ...data }))
+          .finally(logResume);
+      });
+  }
+
+  return tokenRetrievers[url];
+}

package/src/common/log.ts

@@ -8,6 +8,7 @@ import { LogLevels, QuickMessage } from '../types';
 
 type Messages = typeof messages;
 type MessageTypes = keyof Messages;
+let currentProgress: string = undefined;
 
 const logger = (() => {
   try {
@@ -88,7 +89,8 @@ export function logFail(message: string, ...args: Array<string | number | boolea
 }
 
 export function progress(message: string, ...args: Array<string | number | boolean>) {
-  logger.progress(format(message, ...args));
+  currentProgress = format(message, ...args);
+  logger.progress(currentProgress);
 }
 
 export function logReset() {
@@ -96,6 +98,12 @@ export function logReset() {
   logger.stopSpinner();
 }
 
+export function logSuspend() {
+  logReset();
+
+  return () => logger.progress(currentProgress);
+}
+
 export function fail<T extends MessageTypes>(type: T, ...args: Parameters<Messages[T]>): never {
   const message = log(type, ...args);
   const error = new Error(message);

package/src/common/npm.ts

@@ -164,9 +164,20 @@ export function initNpmProject(client: NpmClientType, projectName: string, targe
   return initProject(projectName, target);
 }
 
-export function publishNpmPackage(target = '.', file = '*.tgz', flags: Array<string> = []): Promise<string> {
-  const { publishPackage } = clients.npm;
-  return publishPackage(target, file, ...flags);
+export function publishNpmPackage(
+  target = '.',
+  file = '*.tgz',
+  flags: Array<string> = [],
+  interactive = false,
+): Promise<string> {
+  const { publishPackage, loginUser } = clients.npm;
+  return publishPackage(target, file, ...flags).catch((err) => {
+    if (!interactive) {
+      throw err;
+    }
+
+    return loginUser().then(() => publishNpmPackage(target, file, flags, false));
+  });
 }
 
 export function createNpmPackage(target = '.'): Promise<string> {

package/src/messages.ts

@@ -2088,6 +2088,58 @@ export function publishEmulatorSourcesInvalid_0114(): QuickMessage {
   ];
 }
 
+/**
+ * @kind Error
+ *
+ * @summary
+ * The "feed" provider requires a "--opts.url" argument.
+ *
+ * @abstract
+ * The `piral publish --type release` command requires the selection of a suitable
+ * provider for running successfully. The "feed" provider releases the files to
+ * the a Piral Feed Service with the static page feature.
+ *
+ * Make sure to supply the URL for the feed service via the `--opts.url` command
+ * line flag.
+ *
+ * @example
+ * The following command would specify `https://feed.piral.cloud/api/v1/feed/sample/page`
+ * for the feed service:
+ *
+ * ```sh
+ * piral publish --type release --provider feed --opts.url "https://feed.piral.cloud/api/v1/feed/sample/page" --opts.apikey "foobar123"
+ * ```
+ */
+export function publishFeedMissingUrl_0115(): QuickMessage {
+  return [LogLevels.error, '0115', `The "feed" provider requires a "--opts.url" argument.`];
+}
+
+/**
+ * @kind Error
+ *
+ * @summary
+ * The "feed" provider requires a "--opts.version" argument.
+ *
+ * @abstract
+ * The `piral publish --type release` command requires the selection of a suitable
+ * provider for running successfully. The "feed" provider releases the files to
+ * the a Piral Feed Service with the static page feature.
+ *
+ * Make sure to supply the version either explicitly via the `--opts.version` argument
+ * or implicitly by having the artifacts stored in a sub-directory of the project's root,
+ * which contains a package.json with the version to use.
+ *
+ * @example
+ * The following command would specify version "1.2.3" for the feed service:
+ *
+ * ```sh
+ * piral publish --type release --provider feed --opts.url "..." --opts.apikey "..." --opts.version "1.2.3"
+ * ```
+ */
+export function publishFeedMissingVersion_0116(): QuickMessage {
+  return [LogLevels.error, '0116', `The "feed" provider requires either a "--opts.version" argument or a package.json with a version.`];
+}
+
 /**
  * @kind Warning
  *

package/src/questionnaire.ts

@@ -7,6 +7,7 @@ type FlagType = 'string' | 'number' | 'boolean' | 'object';
 interface Flag {
   name: string;
   type?: FlagType;
+  alias: Array<string>;
   values?: Array<any>;
   describe?: string;
   default?: any;
@@ -16,16 +17,23 @@ interface Flag {
 function getCommandData(retrieve: any) {
   const instructions: Array<Flag> = [];
   const fn = {
+    alias(name: string, altName: string) {
+      return this.swap(name, (flag) => ({
+        ...flag,
+        alias: [...flag.alias, altName],
+      }));
+    },
     positional(name: string, info: Flag) {
       instructions.push({
         ...info,
+        alias: [],
         name,
       });
       return this;
     },
     swap(name: string, swapper: (flag: Flag) => Flag) {
       const [flag] = instructions.filter((m) => m.name === name);
-      const newFlag = swapper(flag || { name });
+      const newFlag = swapper(flag || { name, alias: [] });
 
       if (!flag) {
         instructions.push(newFlag);
@@ -135,7 +143,7 @@ export function runQuestionnaireFor(
   const questions = instructions
     .filter((instruction) => !ignored.includes(instruction.name))
     .filter((instruction) => !acceptAll || (instruction.default === undefined && instruction.required))
-    .filter((instruction) => args[instruction.name] === undefined)
+    .filter((instruction) => [...instruction.alias, instruction.name].every((m) => args[m] === undefined))
     .filter((instruction) => instruction.type !== 'object')
     .map((instruction) => ({
       name: instruction.name,
@@ -146,12 +154,16 @@ export function runQuestionnaireFor(
       validate: instruction.type === 'number' ? (input: string) => !isNaN(+input) : () => true,
     }));
 
+
   return inquirer.prompt(questions).then((answers) => {
     const parameters: any = {};
 
     for (const instruction of instructions) {
       const name = instruction.name;
-      const value = answers[name] ?? ignoredInstructions[name] ?? args[name];
+      const value =
+        answers[name] ??
+        ignoredInstructions[name] ??
+        [...instruction.alias, instruction.name].map((m) => args[m]).find((v) => v !== undefined);
       parameters[name] = value !== undefined ? getValue(instruction.type, value as any) : instruction.default;
     }
 

package/src/release.ts

@@ -1,8 +1,19 @@
-import { basename, resolve } from 'path';
-import { copy, fail } from './common';
+import { basename, dirname, relative, resolve } from 'path';
+import { copy, fail, findFile, FormDataObj, postForm, readBinary } from './common';
 import { availableReleaseProviders } from './helpers';
 import { ReleaseProvider } from './types';
 
+async function getVersion(directory: string) {
+  const data = await findFile(directory, 'package.json');
+
+  if (!data) {
+    fail('packageJsonNotFound_0020');
+  }
+
+  const { version } = require(data);
+  return version;
+}
+
 export interface QualifiedReleaseProvider {
   name: string;
   action: ReleaseProvider;
@@ -12,7 +23,7 @@ const providers: Record<string, ReleaseProvider> = {
   none() {
     return Promise.resolve();
   },
-  async xcopy(files, args) {
+  async xcopy(_, files, args) {
     const { target } = args;
 
     if (!target) {
@@ -21,6 +32,31 @@ const providers: Record<string, ReleaseProvider> = {
 
     await Promise.all(files.map(async (file) => copy(file, resolve(target, basename(file)))));
   },
+  async feed(directory, files, args, interactive) {
+    const { url, apiKey, scheme = 'basic', version = await getVersion(directory) } = args;
+
+    if (!url) {
+      fail('publishFeedMissingUrl_0115');
+    }
+
+    if (!version) {
+      fail('publishFeedMissingVersion_0116');
+    }
+
+    const data: FormDataObj = {
+      version,
+      type: 'custom',
+    };
+
+    for (const file of files) {
+      const relPath = relative(directory, file);
+      const fileName = basename(file);
+      const content = await readBinary(dirname(file), fileName);
+      data[relPath] = [content, fileName];
+    }
+
+    await postForm(url, scheme as any, apiKey, data, {}, undefined, interactive);
+  },
 };
 
 function findReleaseProvider(providerName: string) {
@@ -43,7 +79,13 @@ export function setReleaseProvider(provider: QualifiedReleaseProvider) {
   }
 }
 
-export function publishArtifacts(providerName: string, files: Array<string>, args: Record<string, string>) {
+export function publishArtifacts(
+  providerName: string,
+  directory: string,
+  files: Array<string>,
+  args: Record<string, string>,
+  interactive: boolean,
+) {
   const runRelease = findReleaseProvider(providerName);
-  return runRelease(files, args);
+  return runRelease(directory, files, args, interactive);
 }

package/src/types/common.ts

@@ -42,7 +42,7 @@ export interface Bundler {
 }
 
 export interface ReleaseProvider {
-  (files: Array<string>, args: Record<string, string>): Promise<void>;
+  (directory: string, files: Array<string>, args: Record<string, string>, interactive: boolean): Promise<void>;
 }
 
 export interface TemplateFileLocation {