@teambit/cli 0.0.0-387ca83bd6d05e8441bf8d4e938b4a402307cc6b

package/dist/command-groups.d.ts

@@ -0,0 +1,31 @@
+/**
+ * These are the main group.
+ * It's possible to create new groups by calling `cliMain.registerGroup()`.
+ */
+export declare const groups: {
+    'workspace-setup': string;
+    collaborate: string;
+    'info-analysis': string;
+    'workspace-tools': string;
+    'component-config': string;
+    'component-development': string;
+    dependencies: string;
+    'version-control': string;
+    testing: string;
+    'run-serve': string;
+    system: string;
+    auth: string;
+    advanced: string;
+    ungrouped: string;
+    start: string;
+    development: string;
+    discover: string;
+    info: string;
+    general: string;
+};
+export type Group = keyof typeof groups;
+type GroupDescription = string;
+export type GroupsType = {
+    [groupName: string]: GroupDescription;
+};
+export {};

package/dist/command-groups.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.groups = void 0;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * They might be needed for backward compatibility.
+ */
+const oldGroups = {
+  start: 'Start a working area',
+  development: 'Develop components',
+  discover: 'Explore components',
+  info: 'View components',
+  general: 'Workspace commands'
+};
+
+/**
+ * These are the main group.
+ * It's possible to create new groups by calling `cliMain.registerGroup()`.
+ */
+const groups = exports.groups = _objectSpread(_objectSpread({}, oldGroups), {}, {
+  'workspace-setup': 'Workspace & Project Setup',
+  collaborate: 'Collaboration & Remote',
+  'info-analysis': 'Information & Analysis',
+  'workspace-tools': 'Workspace Tools',
+  'component-config': 'Component Configuration',
+  'component-development': 'Component Development',
+  dependencies: 'Dependencies & Packages',
+  'version-control': 'Version Control',
+  testing: 'Testing & Quality',
+  'run-serve': 'Run & Serve',
+  system: 'System & Utility',
+  auth: 'Authentication & Cloud',
+  advanced: 'Advanced/Debug',
+  ungrouped: 'Ungrouped'
+});
+
+//# sourceMappingURL=command-groups.js.map

package/dist/command-groups.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["oldGroups","start","development","discover","info","general","groups","exports","_objectSpread","collaborate","dependencies","testing","system","auth","advanced","ungrouped"],"sources":["command-groups.ts"],"sourcesContent":["/**\n * They might be needed for backward compatibility.\n */\nconst oldGroups = {\n  start: 'Start a working area',\n  development: 'Develop components',\n  discover: 'Explore components',\n  info: 'View components',\n  general: 'Workspace commands',\n};\n\n/**\n * These are the main group.\n * It's possible to create new groups by calling `cliMain.registerGroup()`.\n */\nexport const groups = {\n  ...oldGroups,\n  'workspace-setup': 'Workspace & Project Setup',\n  collaborate: 'Collaboration & Remote',\n  'info-analysis': 'Information & Analysis',\n  'workspace-tools': 'Workspace Tools',\n  'component-config': 'Component Configuration',\n  'component-development': 'Component Development',\n  dependencies: 'Dependencies & Packages',\n  'version-control': 'Version Control',\n  testing: 'Testing & Quality',\n  'run-serve': 'Run & Serve',\n  system: 'System & Utility',\n  auth: 'Authentication & Cloud',\n  advanced: 'Advanced/Debug',\n  ungrouped: 'Ungrouped',\n};\n\nexport type Group = keyof typeof groups;\n\ntype GroupDescription = string;\n\nexport type GroupsType = { [groupName: string]: GroupDescription };\n"],"mappings":";;;;;;;;;;;AAAA;AACA;AACA;AACA,MAAMA,SAAS,GAAG;EAChBC,KAAK,EAAE,sBAAsB;EAC7BC,WAAW,EAAE,oBAAoB;EACjCC,QAAQ,EAAE,oBAAoB;EAC9BC,IAAI,EAAE,iBAAiB;EACvBC,OAAO,EAAE;AACX,CAAC;;AAED;AACA;AACA;AACA;AACO,MAAMC,MAAM,GAAAC,OAAA,CAAAD,MAAA,GAAAE,aAAA,CAAAA,aAAA,KACdR,SAAS;EACZ,iBAAiB,EAAE,2BAA2B;EAC9CS,WAAW,EAAE,wBAAwB;EACrC,eAAe,EAAE,wBAAwB;EACzC,iBAAiB,EAAE,iBAAiB;EACpC,kBAAkB,EAAE,yBAAyB;EAC7C,uBAAuB,EAAE,uBAAuB;EAChDC,YAAY,EAAE,yBAAyB;EACvC,iBAAiB,EAAE,iBAAiB;EACpCC,OAAO,EAAE,mBAAmB;EAC5B,WAAW,EAAE,aAAa;EAC1BC,MAAM,EAAE,kBAAkB;EAC1BC,IAAI,EAAE,wBAAwB;EAC9BC,QAAQ,EAAE,gBAAgB;EAC1BC,SAAS,EAAE;AAAW,EACvB","ignoreList":[]}

package/dist/command-helper.d.ts

@@ -0,0 +1,25 @@
+import { Command } from './command';
+type ArgData = {
+    /**
+     * as it appears in the command name, e.g. "component-pattern..."
+     */
+    nameRaw: string;
+    /**
+     * to make it valid as a js variable name, e.g. "componentPattern"
+     */
+    nameCamelCase: string;
+    required: boolean;
+    description?: string;
+    isArray?: boolean;
+};
+export declare function getArgsData(cmd: Command): ArgData[];
+type FlagData = {
+    name: string;
+    alias?: string;
+    description: string;
+    type: 'string' | 'boolean';
+    requiresArg: boolean;
+};
+export declare function getFlagsData(cmd: Command): FlagData[];
+export declare function getCommandName(cmd: Command): string;
+export {};

package/dist/command-helper.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getArgsData = getArgsData;
+exports.getCommandName = getCommandName;
+exports.getFlagsData = getFlagsData;
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function getArgsData(cmd) {
+  const commandSplit = cmd.name.split(' ');
+  commandSplit.shift(); // remove the first element, it's the command-name
+
+  return commandSplit.map(existArg => {
+    const trimmed = existArg.trim();
+    if (!trimmed.startsWith('<') && !trimmed.startsWith('[') || !trimmed.endsWith('>') && !trimmed.endsWith(']')) {
+      throw new Error(`expect arg "${trimmed}" of "${cmd.name}" to be wrapped with "[]" or "<>"`);
+    }
+    // remove the opening and closing brackets
+    const withoutBrackets = trimmed.slice(1, -1);
+    const foundInArguments = cmd.arguments?.find(arg => arg.name === withoutBrackets);
+    return {
+      nameRaw: withoutBrackets,
+      nameCamelCase: (0, _lodash().camelCase)(withoutBrackets),
+      // it also removes the "..." if exists
+      required: trimmed.startsWith('<'),
+      description: foundInArguments?.description,
+      isArray: withoutBrackets.endsWith('...')
+    };
+  });
+}
+function getFlagsData(cmd) {
+  const options = cmd.options;
+  if (!options) return [];
+  return options.map(opt => {
+    const [alias, flag, description] = opt;
+    const name = flag.split(' ')[0];
+    const type = flag.includes('<') || flag.includes('[') ? 'string' : 'boolean';
+    const requiresArg = flag.includes('<');
+    return {
+      name,
+      alias,
+      description,
+      type,
+      requiresArg
+    };
+  });
+}
+function getCommandName(cmd) {
+  return cmd.name.split(' ')[0];
+}
+
+//# sourceMappingURL=command-helper.js.map

package/dist/command-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_lodash","data","require","getArgsData","cmd","commandSplit","name","split","shift","map","existArg","trimmed","trim","startsWith","endsWith","Error","withoutBrackets","slice","foundInArguments","arguments","find","arg","nameRaw","nameCamelCase","camelCase","required","description","isArray","getFlagsData","options","opt","alias","flag","type","includes","requiresArg","getCommandName"],"sources":["command-helper.ts"],"sourcesContent":["import { Command } from './command';\nimport { camelCase } from 'lodash';\n\ntype ArgData = {\n  /**\n   * as it appears in the command name, e.g. \"component-pattern...\"\n   */\n  nameRaw: string;\n  /**\n   * to make it valid as a js variable name, e.g. \"componentPattern\"\n   */\n  nameCamelCase: string;\n  required: boolean;\n  description?: string;\n  isArray?: boolean;\n}\n\nexport function getArgsData(cmd: Command): ArgData[] {\n  const commandSplit = cmd.name.split(' ');\n  commandSplit.shift(); // remove the first element, it's the command-name\n\n  return commandSplit.map((existArg) => {\n    const trimmed = existArg.trim();\n    if ((!trimmed.startsWith('<') && !trimmed.startsWith('[')) || (!trimmed.endsWith('>') && !trimmed.endsWith(']'))) {\n      throw new Error(`expect arg \"${trimmed}\" of \"${cmd.name}\" to be wrapped with \"[]\" or \"<>\"`);\n    }\n    // remove the opening and closing brackets\n    const withoutBrackets = trimmed.slice(1, -1);\n    const foundInArguments = cmd.arguments?.find((arg) => arg.name === withoutBrackets);\n\n    return {\n      nameRaw: withoutBrackets,\n      nameCamelCase: camelCase(withoutBrackets), // it also removes the \"...\" if exists\n      required: trimmed.startsWith('<'),\n      description: foundInArguments?.description,\n      isArray: withoutBrackets.endsWith('...'),\n    }\n  });\n}\n\ntype FlagData = {\n  name: string;\n  alias?: string;\n  description: string;\n  type: 'string' | 'boolean';\n  requiresArg: boolean; // a value is required after the flag. e.g. 'message <message>'\n}\n\nexport function getFlagsData(cmd: Command): FlagData[] {\n  const options = cmd.options;\n  if (!options) return [];\n  return options.map((opt) => {\n    const [alias, flag, description] = opt;\n    const name = flag.split(' ')[0];\n    const type = flag.includes('<') || flag.includes('[') ? 'string' : 'boolean';\n    const requiresArg = flag.includes('<');\n\n    return {\n      name,\n      alias,\n      description,\n      type,\n      requiresArg,\n    }\n  });\n}\n\nexport function getCommandName(cmd: Command): string {\n  return cmd.name.split(' ')[0];\n}"],"mappings":";;;;;;;;AACA,SAAAA,QAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,OAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAgBO,SAASE,WAAWA,CAACC,GAAY,EAAa;EACnD,MAAMC,YAAY,GAAGD,GAAG,CAACE,IAAI,CAACC,KAAK,CAAC,GAAG,CAAC;EACxCF,YAAY,CAACG,KAAK,CAAC,CAAC,CAAC,CAAC;;EAEtB,OAAOH,YAAY,CAACI,GAAG,CAAEC,QAAQ,IAAK;IACpC,MAAMC,OAAO,GAAGD,QAAQ,CAACE,IAAI,CAAC,CAAC;IAC/B,IAAK,CAACD,OAAO,CAACE,UAAU,CAAC,GAAG,CAAC,IAAI,CAACF,OAAO,CAACE,UAAU,CAAC,GAAG,CAAC,IAAM,CAACF,OAAO,CAACG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAACH,OAAO,CAACG,QAAQ,CAAC,GAAG,CAAE,EAAE;MAChH,MAAM,IAAIC,KAAK,CAAC,eAAeJ,OAAO,SAASP,GAAG,CAACE,IAAI,mCAAmC,CAAC;IAC7F;IACA;IACA,MAAMU,eAAe,GAAGL,OAAO,CAACM,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC5C,MAAMC,gBAAgB,GAAGd,GAAG,CAACe,SAAS,EAAEC,IAAI,CAAEC,GAAG,IAAKA,GAAG,CAACf,IAAI,KAAKU,eAAe,CAAC;IAEnF,OAAO;MACLM,OAAO,EAAEN,eAAe;MACxBO,aAAa,EAAE,IAAAC,mBAAS,EAACR,eAAe,CAAC;MAAE;MAC3CS,QAAQ,EAAEd,OAAO,CAACE,UAAU,CAAC,GAAG,CAAC;MACjCa,WAAW,EAAER,gBAAgB,EAAEQ,WAAW;MAC1CC,OAAO,EAAEX,eAAe,CAACF,QAAQ,CAAC,KAAK;IACzC,CAAC;EACH,CAAC,CAAC;AACJ;AAUO,SAASc,YAAYA,CAACxB,GAAY,EAAc;EACrD,MAAMyB,OAAO,GAAGzB,GAAG,CAACyB,OAAO;EAC3B,IAAI,CAACA,OAAO,EAAE,OAAO,EAAE;EACvB,OAAOA,OAAO,CAACpB,GAAG,CAAEqB,GAAG,IAAK;IAC1B,MAAM,CAACC,KAAK,EAAEC,IAAI,EAAEN,WAAW,CAAC,GAAGI,GAAG;IACtC,MAAMxB,IAAI,GAAG0B,IAAI,CAACzB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC/B,MAAM0B,IAAI,GAAGD,IAAI,CAACE,QAAQ,CAAC,GAAG,CAAC,IAAIF,IAAI,CAACE,QAAQ,CAAC,GAAG,CAAC,GAAG,QAAQ,GAAG,SAAS;IAC5E,MAAMC,WAAW,GAAGH,IAAI,CAACE,QAAQ,CAAC,GAAG,CAAC;IAEtC,OAAO;MACL5B,IAAI;MACJyB,KAAK;MACLL,WAAW;MACXO,IAAI;MACJE;IACF,CAAC;EACH,CAAC,CAAC;AACJ;AAEO,SAASC,cAAcA,CAAChC,GAAY,EAAU;EACnD,OAAOA,GAAG,CAACE,IAAI,CAACC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAC/B","ignoreList":[]}

package/dist/command-runner.d.ts

@@ -0,0 +1,35 @@
+import { CLIArgs, Command, Flags } from './command';
+import { OnCommandStartSlot } from './cli.main.runtime';
+type CommandResult = {
+    data: any;
+    exitCode: number;
+};
+export declare class CommandRunner {
+    private command;
+    private args;
+    private flags;
+    private onCommandStartSlot;
+    private commandName;
+    constructor(command: Command, args: CLIArgs, flags: Flags, onCommandStartSlot: OnCommandStartSlot);
+    /**
+     * run command using one of the handler, "json"/"report"/"render". once done, exit the process.
+     */
+    runCommand(shouldReturnResult?: boolean): Promise<void | CommandResult>;
+    private bootstrapCommand;
+    private invokeOnCommandStart;
+    /**
+     * this works for both, Harmony commands and Legacy commands (the legacy-command-adapter
+     * implements json() method)
+     */
+    private runJsonHandler;
+    private runReportHandler;
+    private runWaitHandler;
+    /**
+     * the loader and logger.console write output to the console during the command execution.
+     * for internals commands, such as, _put, _fetch, the command.loader = false.
+     */
+    private determineConsoleWritingDuringCommand;
+    private writeAndExit;
+}
+export declare function parseCommandName(commandName: string): string;
+export {};

package/dist/command-runner.js

@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CommandRunner = void 0;
+exports.parseCommandName = parseCommandName;
+function _legacy() {
+  const data = require("@teambit/legacy.logger");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy2() {
+  const data = require("@teambit/legacy.loader");
+  _legacy2 = function () {
+    return data;
+  };
+  return data;
+}
+function _handleErrors() {
+  const data = require("./handle-errors");
+  _handleErrors = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy3() {
+  const data = require("@teambit/legacy.constants");
+  _legacy3 = function () {
+    return data;
+  };
+  return data;
+}
+function _globalFlags() {
+  const data = _interopRequireDefault(require("./global-flags"));
+  _globalFlags = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy4() {
+  const data = require("@teambit/legacy.analytics");
+  _legacy4 = function () {
+    return data;
+  };
+  return data;
+}
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+  _pMapSeries = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class CommandRunner {
+  constructor(command, args, flags, onCommandStartSlot) {
+    this.command = command;
+    this.args = args;
+    this.flags = flags;
+    this.onCommandStartSlot = onCommandStartSlot;
+    _defineProperty(this, "commandName", void 0);
+    this.commandName = parseCommandName(this.command.name);
+  }
+
+  /**
+   * run command using one of the handler, "json"/"report"/"render". once done, exit the process.
+   */
+  async runCommand(shouldReturnResult = false) {
+    try {
+      this.bootstrapCommand();
+      await this.invokeOnCommandStart();
+      this.determineConsoleWritingDuringCommand();
+      if (this.flags.json) {
+        return await this.runJsonHandler(shouldReturnResult);
+      }
+      if (this.command.report) {
+        return await this.runReportHandler(shouldReturnResult);
+      }
+      if (this.command.wait) {
+        return await this.runWaitHandler();
+      }
+    } catch (err) {
+      if (shouldReturnResult) throw err;
+      return (0, _handleErrors().handleErrorAndExit)(err, this.commandName);
+    }
+    throw new Error(`command "${this.commandName}" doesn't implement "render" nor "report" nor "wait" methods`);
+  }
+  bootstrapCommand() {
+    try {
+      _legacy4().Analytics.init(this.commandName, this.flags, this.args);
+    } catch (err) {
+      // ignoring the error, we don't want to fail the app if analytics failed.
+      _legacy().logger.error('failed to initialize analytics', err);
+    }
+    _legacy().logger.info(`[*] started a new command: "${this.commandName}" with the following data:`, {
+      args: this.args,
+      flags: this.flags
+    });
+    const token = this.flags[_legacy3().TOKEN_FLAG_NAME];
+    if (token) {
+      _globalFlags().default.token = token.toString();
+    }
+  }
+  async invokeOnCommandStart() {
+    const funcs = this.onCommandStartSlot.values();
+    await (0, _pMapSeries().default)(funcs, onCommandStart => onCommandStart(this.commandName, this.args, this.flags));
+  }
+
+  /**
+   * this works for both, Harmony commands and Legacy commands (the legacy-command-adapter
+   * implements json() method)
+   */
+  async runJsonHandler(shouldReturnResult = false) {
+    if (!this.flags.json) return undefined;
+    if (!this.command.json) throw new Error(`command "${this.commandName}" doesn't implement "json" method`);
+    const result = await this.command.json(this.args, this.flags);
+    const code = result.code || 0;
+    const data = result.data || result;
+    if (shouldReturnResult) return {
+      data,
+      exitCode: code
+    };
+    const isJsonStream = Boolean(this.flags.stream);
+    if (isJsonStream) data.end = true;
+    const jsonStr = isJsonStream ? `${JSON.stringify(data)}\n` : JSON.stringify(data, null, 2);
+    await this.writeAndExit(jsonStr, code);
+  }
+  async runReportHandler(shouldReturnResult = false) {
+    if (!this.command.report) throw new Error('runReportHandler expects command.report to be implemented');
+    const result = await this.command.report(this.args, this.flags);
+    _legacy2().loader.off();
+    const data = typeof result === 'string' ? result : result.data;
+    const exitCode = typeof result === 'string' ? 0 : result.code;
+    if (shouldReturnResult) return {
+      data,
+      exitCode
+    };
+    await this.writeAndExit(`${data}\n`, exitCode);
+  }
+  async runWaitHandler() {
+    if (!this.command.wait) throw new Error('runReportHandler expects command.wait to be implemented');
+    await this.command.wait(this.args, this.flags);
+  }
+
+  /**
+   * the loader and logger.console write output to the console during the command execution.
+   * for internals commands, such as, _put, _fetch, the command.loader = false.
+   */
+  determineConsoleWritingDuringCommand() {
+    if (this.command.loader && !this.flags.json && !this.flags['get-yargs-completions'] && !_legacy().shouldDisableLoader) {
+      _legacy2().loader.on();
+      _legacy2().loader.start(`running command "${this.commandName}"...`);
+      _legacy().logger.shouldWriteToConsole = true;
+    } else {
+      _legacy2().loader.off();
+      _legacy().logger.shouldWriteToConsole = false;
+    }
+  }
+  async writeAndExit(data, exitCode) {
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    return process.stdout.write(data, async () => _legacy().logger.exitAfterFlush(exitCode, this.commandName, data));
+  }
+}
+exports.CommandRunner = CommandRunner;
+function parseCommandName(commandName) {
+  if (!commandName) return '';
+  return commandName.split(' ')[0];
+}
+
+//# sourceMappingURL=command-runner.js.map

package/dist/command-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_legacy","data","require","_legacy2","_handleErrors","_legacy3","_globalFlags","_interopRequireDefault","_legacy4","_pMapSeries","e","__esModule","default","_defineProperty","r","t","_toPropertyKey","Object","defineProperty","value","enumerable","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","CommandRunner","constructor","command","args","flags","onCommandStartSlot","commandName","parseCommandName","name","runCommand","shouldReturnResult","bootstrapCommand","invokeOnCommandStart","determineConsoleWritingDuringCommand","json","runJsonHandler","report","runReportHandler","wait","runWaitHandler","err","handleErrorAndExit","Error","Analytics","init","logger","error","info","token","TOKEN_FLAG_NAME","globalFlags","toString","funcs","values","pMapSeries","onCommandStart","undefined","result","code","exitCode","isJsonStream","Boolean","stream","end","jsonStr","JSON","stringify","writeAndExit","loader","off","shouldDisableLoader","on","start","shouldWriteToConsole","process","stdout","write","exitAfterFlush","exports","split"],"sources":["command-runner.ts"],"sourcesContent":["import { logger, shouldDisableLoader } from '@teambit/legacy.logger';\nimport { CLIArgs, Command, Flags } from './command';\nimport { loader } from '@teambit/legacy.loader';\nimport { handleErrorAndExit } from './handle-errors';\nimport { TOKEN_FLAG_NAME } from '@teambit/legacy.constants';\nimport globalFlags from './global-flags';\nimport { Analytics } from '@teambit/legacy.analytics';\nimport { OnCommandStartSlot } from './cli.main.runtime';\nimport pMapSeries from 'p-map-series';\n\ntype CommandResult = { data: any; exitCode: number };\n\nexport class CommandRunner {\n  private commandName: string;\n  constructor(\n    private command: Command,\n    private args: CLIArgs,\n    private flags: Flags,\n    private onCommandStartSlot: OnCommandStartSlot\n  ) {\n    this.commandName = parseCommandName(this.command.name);\n  }\n\n  /**\n   * run command using one of the handler, \"json\"/\"report\"/\"render\". once done, exit the process.\n   */\n  async runCommand(shouldReturnResult = false): Promise<void | CommandResult> {\n    try {\n      this.bootstrapCommand();\n      await this.invokeOnCommandStart();\n      this.determineConsoleWritingDuringCommand();\n      if (this.flags.json) {\n        return await this.runJsonHandler(shouldReturnResult);\n      }\n      if (this.command.report) {\n        return await this.runReportHandler(shouldReturnResult);\n      }\n      if (this.command.wait) {\n        return await this.runWaitHandler();\n      }\n    } catch (err: any) {\n      if (shouldReturnResult) throw err;\n      return handleErrorAndExit(err, this.commandName);\n    }\n\n    throw new Error(`command \"${this.commandName}\" doesn't implement \"render\" nor \"report\" nor \"wait\" methods`);\n  }\n\n  private bootstrapCommand() {\n    try {\n      Analytics.init(this.commandName, this.flags, this.args);\n    } catch (err: any) {\n      // ignoring the error, we don't want to fail the app if analytics failed.\n      logger.error('failed to initialize analytics', err);\n    }\n    logger.info(`[*] started a new command: \"${this.commandName}\" with the following data:`, {\n      args: this.args,\n      flags: this.flags,\n    });\n    const token = this.flags[TOKEN_FLAG_NAME];\n    if (token) {\n      globalFlags.token = token.toString();\n    }\n  }\n\n  private async invokeOnCommandStart() {\n    const funcs = this.onCommandStartSlot.values();\n    await pMapSeries(funcs, (onCommandStart) => onCommandStart(this.commandName, this.args, this.flags));\n  }\n\n  /**\n   * this works for both, Harmony commands and Legacy commands (the legacy-command-adapter\n   * implements json() method)\n   */\n  private async runJsonHandler(shouldReturnResult = false): Promise<CommandResult | undefined> {\n    if (!this.flags.json) return undefined;\n    if (!this.command.json) throw new Error(`command \"${this.commandName}\" doesn't implement \"json\" method`);\n    const result = await this.command.json(this.args, this.flags);\n    const code = result.code || 0;\n    const data = result.data || result;\n    if (shouldReturnResult) return { data, exitCode: code };\n    const isJsonStream = Boolean(this.flags.stream);\n    if (isJsonStream) data.end = true;\n    const jsonStr = isJsonStream ? `${JSON.stringify(data)}\\n` : JSON.stringify(data, null, 2);\n    await this.writeAndExit(jsonStr, code);\n  }\n\n  private async runReportHandler(shouldReturnResult = false): Promise<CommandResult | undefined> {\n    if (!this.command.report) throw new Error('runReportHandler expects command.report to be implemented');\n    const result = await this.command.report(this.args, this.flags);\n    loader.off();\n    const data = typeof result === 'string' ? result : result.data;\n    const exitCode = typeof result === 'string' ? 0 : result.code;\n    if (shouldReturnResult) return { data, exitCode };\n    await this.writeAndExit(`${data}\\n`, exitCode);\n  }\n\n  private async runWaitHandler() {\n    if (!this.command.wait) throw new Error('runReportHandler expects command.wait to be implemented');\n    await this.command.wait(this.args, this.flags);\n  }\n\n  /**\n   * the loader and logger.console write output to the console during the command execution.\n   * for internals commands, such as, _put, _fetch, the command.loader = false.\n   */\n  private determineConsoleWritingDuringCommand() {\n    if (this.command.loader && !this.flags.json && !this.flags['get-yargs-completions'] && !shouldDisableLoader) {\n      loader.on();\n      loader.start(`running command \"${this.commandName}\"...`);\n      logger.shouldWriteToConsole = true;\n    } else {\n      loader.off();\n      logger.shouldWriteToConsole = false;\n    }\n  }\n\n  private async writeAndExit(data: string, exitCode: number) {\n    // eslint-disable-next-line @typescript-eslint/no-misused-promises\n    return process.stdout.write(data, async () => logger.exitAfterFlush(exitCode, this.commandName, data));\n  }\n}\n\nexport function parseCommandName(commandName: string): string {\n  if (!commandName) return '';\n  return commandName.split(' ')[0];\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/command.d.ts

@@ -0,0 +1,130 @@
+import { Group } from './command-groups';
+type CommandOption = [string, string, string];
+export type CommandOptions = Array<CommandOption>;
+export interface Command {
+    /**
+     * Name of command with arguments:
+     * <> for mandatory arguments.
+     * [] for optional arguments.
+     * e.g. 'add <path>'
+     */
+    name: string;
+    /**
+     * command alias (for example: 't' for 'tag')
+     */
+    alias?: string;
+    /**
+     * The description of the command. Being used in the commands summery (`bit --help`) and the help (e.g. `bit create --help`).
+     * should be short and precise. not more than one line. (use extendedDescription for more info).
+     */
+    description: string;
+    /**
+     * The extended description of the command. Will be seen in only in the command help, just after the description.
+     */
+    extendedDescription?: string;
+    /**
+     * url to a doc page explaining the command. shown in the command help just after the extendedDescription.
+     * if a relative url is entered, the base url will be retrieved from `teambit.community/community` aspect.
+     */
+    helpUrl?: string;
+    /**
+     * allow grouping of commands to hint summery renderer
+     * Places in default automatic help
+     */
+    group?: Group | string;
+    /**
+     * should a command be exposed to the user (by bit help).
+     * e.g. experimental or plumbing commands should be hidden.
+     */
+    private?: boolean;
+    /**
+     * should turn on Loader.
+     * the default is false for internal-commands and true for others.
+     * @see cliMain.setDefaults()
+     */
+    loader?: boolean;
+    /**
+     * Array of command options where each element is a tuple.
+     * ['flag alias', 'flag name', 'flag description']
+     * for example:
+     * ['j', 'json', 'output json format']
+     */
+    options: CommandOptions;
+    /**
+     * arguments are defined in the "name" property, and that's where the source of truth is.
+     * this prop is optional and provides a way to describe the args. later, it'll support more fields, such as defaultValue.
+     * if this is set, it'll be shown in the command help under "Arguments" section.
+     */
+    arguments?: CommandArg[];
+    /**
+     * sub commands for example:
+     * bit capsule list to list active capsules.
+     */
+    commands?: Command[];
+    /**
+     * interact with a remote, e.g. "export" push to a remote
+     * for now, the only difference is that they get a "token" flag to authenticate anonymously.
+     */
+    remoteOp?: boolean;
+    /**
+     * if true, it indicates that it doesn't need the workspace to work and can be executed outside a
+     * workspace
+     */
+    skipWorkspace?: boolean;
+    /**
+     * optionally, give some examples how to use the command.
+     */
+    examples?: Example[];
+    /**
+     * whether to load aspects set in workspace.jsonc before running the command.
+     * default is true.
+     */
+    loadAspects?: boolean;
+    /**
+     * do not set this. it is being set once the command run.
+     * the values are those followed `--` in the command line. (e.g. `bit import -- --no-optional`)
+     */
+    _packageManagerArgs?: string[];
+    /**
+     * Command handler which prints the return value to the console and exits.
+     * If the command has both, `render` and `report`, this one will be called when process.isTTY is false.
+     * @param args  - arguments object as defined in name.
+     * @param flags - command flags as described in options.
+     * @return - Report object. The Report.data is printed to the stdout as is.
+     */
+    report?(args: CLIArgs, flags: Flags): Promise<string | Report>;
+    /**
+     * Command handler which never exits the process
+     * @param args  - arguments object as defined in name.
+     * @param flags - command flags as described in options.
+     */
+    wait?(args: CLIArgs, flags: Flags): Promise<void>;
+    /**
+     * Optional handler to provide a raw result of the command.
+     * Will be go called if '-j'/'--json' option is provided by user.
+     * @param args  - arguments object as defined in name.
+     * @param flags - command flags as described in options.
+     * @return a GenericObject to be rendered to string (by json.stringify) in the console.
+     */
+    json?(args: CLIArgs, flags: Flags): Promise<GenericObject>;
+}
+export type Flags = {
+    [flagName: string]: string | boolean | undefined | any;
+};
+export type CLIArgs = Array<string[] | string>;
+export type GenericObject = {
+    [k: string]: any;
+};
+export type Report = {
+    data: string;
+    code: number;
+};
+export type CommandArg = {
+    name: string;
+    description?: string;
+};
+export type Example = {
+    cmd: string;
+    description: string;
+};
+export {};

package/dist/command.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=command.js.map

package/dist/command.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["command.ts"],"sourcesContent":["import { Group } from './command-groups';\n\ntype CommandOption = [string, string, string];\nexport type CommandOptions = Array<CommandOption>;\n\nexport interface Command {\n  /**\n   * Name of command with arguments:\n   * <> for mandatory arguments.\n   * [] for optional arguments.\n   * e.g. 'add <path>'\n   */\n  name: string;\n\n  /**\n   * command alias (for example: 't' for 'tag')\n   */\n  alias?: string;\n\n  /**\n   * The description of the command. Being used in the commands summery (`bit --help`) and the help (e.g. `bit create --help`).\n   * should be short and precise. not more than one line. (use extendedDescription for more info).\n   */\n  description: string;\n\n  /**\n   * The extended description of the command. Will be seen in only in the command help, just after the description.\n   */\n  extendedDescription?: string;\n\n  /**\n   * url to a doc page explaining the command. shown in the command help just after the extendedDescription.\n   * if a relative url is entered, the base url will be retrieved from `teambit.community/community` aspect.\n   */\n  helpUrl?: string;\n\n  /**\n   * allow grouping of commands to hint summery renderer\n   * Places in default automatic help\n   */\n  group?: Group | string;\n\n  /**\n   * should a command be exposed to the user (by bit help).\n   * e.g. experimental or plumbing commands should be hidden.\n   */\n  private?: boolean;\n\n  /**\n   * should turn on Loader.\n   * the default is false for internal-commands and true for others.\n   * @see cliMain.setDefaults()\n   */\n  loader?: boolean;\n\n  /**\n   * Array of command options where each element is a tuple.\n   * ['flag alias', 'flag name', 'flag description']\n   * for example:\n   * ['j', 'json', 'output json format']\n   */\n  options: CommandOptions;\n\n  /**\n   * arguments are defined in the \"name\" property, and that's where the source of truth is.\n   * this prop is optional and provides a way to describe the args. later, it'll support more fields, such as defaultValue.\n   * if this is set, it'll be shown in the command help under \"Arguments\" section.\n   */\n  arguments?: CommandArg[];\n\n  /**\n   * sub commands for example:\n   * bit capsule list to list active capsules.\n   */\n  commands?: Command[];\n\n  /**\n   * interact with a remote, e.g. \"export\" push to a remote\n   * for now, the only difference is that they get a \"token\" flag to authenticate anonymously.\n   */\n  remoteOp?: boolean;\n\n  /**\n   * if true, it indicates that it doesn't need the workspace to work and can be executed outside a\n   * workspace\n   */\n  skipWorkspace?: boolean;\n\n  /**\n   * optionally, give some examples how to use the command.\n   */\n  examples?: Example[];\n\n  /**\n   * whether to load aspects set in workspace.jsonc before running the command.\n   * default is true.\n   */\n  loadAspects?: boolean;\n\n  /**\n   * do not set this. it is being set once the command run.\n   * the values are those followed `--` in the command line. (e.g. `bit import -- --no-optional`)\n   */\n  _packageManagerArgs?: string[];\n\n  /**\n   * Command handler which prints the return value to the console and exits.\n   * If the command has both, `render` and `report`, this one will be called when process.isTTY is false.\n   * @param args  - arguments object as defined in name.\n   * @param flags - command flags as described in options.\n   * @return - Report object. The Report.data is printed to the stdout as is.\n   */\n  report?(args: CLIArgs, flags: Flags): Promise<string | Report>;\n\n  /**\n   * Command handler which never exits the process\n   * @param args  - arguments object as defined in name.\n   * @param flags - command flags as described in options.\n   */\n  wait?(args: CLIArgs, flags: Flags): Promise<void>;\n\n  /**\n   * Optional handler to provide a raw result of the command.\n   * Will be go called if '-j'/'--json' option is provided by user.\n   * @param args  - arguments object as defined in name.\n   * @param flags - command flags as described in options.\n   * @return a GenericObject to be rendered to string (by json.stringify) in the console.\n   */\n  json?(args: CLIArgs, flags: Flags): Promise<GenericObject>;\n}\nexport type Flags = { [flagName: string]: string | boolean | undefined | any };\nexport type CLIArgs = Array<string[] | string>;\nexport type GenericObject = { [k: string]: any };\nexport type Report = { data: string; code: number };\nexport type CommandArg = { name: string; description?: string };\nexport type Example = { cmd: string; description: string };\n"],"mappings":"","ignoreList":[]}

package/dist/completion.cmd.d.ts

@@ -0,0 +1,9 @@
+import { Command } from './command';
+export declare class CompletionCmd implements Command {
+    name: string;
+    description: string;
+    alias: string;
+    group: string;
+    options: never[];
+    private: boolean;
+}

package/dist/completion.cmd.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CompletionCmd = void 0;
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class CompletionCmd {
+  constructor() {
+    _defineProperty(this, "name", 'completion');
+    _defineProperty(this, "description", 'enable bash/zsh-completion shortcuts for commands and options');
+    _defineProperty(this, "alias", '');
+    _defineProperty(this, "group", 'system');
+    _defineProperty(this, "options", []);
+    _defineProperty(this, "private", true);
+  }
+}
+exports.CompletionCmd = CompletionCmd;
+
+//# sourceMappingURL=completion.cmd.js.map

package/dist/completion.cmd.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CompletionCmd","constructor","_defineProperty","exports"],"sources":["completion.cmd.ts"],"sourcesContent":["import { Command } from './command';\n\nexport class CompletionCmd implements Command {\n  name = 'completion';\n  description = 'enable bash/zsh-completion shortcuts for commands and options';\n  alias = '';\n  group = 'system';\n  options = [];\n  private = true;\n}\n"],"mappings":";;;;;;;;;AAEO,MAAMA,aAAa,CAAoB;EAAAC,YAAA;IAAAC,eAAA,eACrC,YAAY;IAAAA,eAAA,sBACL,+DAA+D;IAAAA,eAAA,gBACrE,EAAE;IAAAA,eAAA,gBACF,QAAQ;IAAAA,eAAA,kBACN,EAAE;IAAAA,eAAA,kBACF,IAAI;EAAA;AAChB;AAACC,OAAA,CAAAH,aAAA,GAAAA,aAAA","ignoreList":[]}

package/dist/default-error-handler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * if err.userError is set, it inherits from AbstractError, which are user errors not Bit errors
+ * and should not be reported to Sentry.
+ * reason why we don't check (err instanceof AbstractError) is that it could be thrown from a fork,
+ * in which case, it loses its class and has only the fields.
+ */
+export declare function sendToAnalyticsAndSentry(err: Error): void;
+declare const _default: (err: Error) => {
+    message: string;
+    error: Error;
+};
+export default _default;