@backstage/cli 0.28.0-next.1 → 0.28.0

package/dist/lib/codeowners/codeowners.cjs.js

@@ -0,0 +1,92 @@
+'use strict';
+
+var fs = require('fs-extra');
+var path = require('path');
+var paths = require('../paths.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+const TEAM_ID_RE = /^@[-\w]+\/[-\w]+$/;
+const USER_ID_RE = /^@[-\w]+$/;
+const EMAIL_RE = /^[^@]+@[-.\w]+\.[-\w]+$/i;
+const DEFAULT_OWNER = "@backstage/maintainers";
+async function getCodeownersFilePath(rootDir) {
+  const possiblePaths = [
+    path__default.default.join(rootDir, ".github", "CODEOWNERS"),
+    path__default.default.join(rootDir, ".gitlab", "CODEOWNERS"),
+    path__default.default.join(rootDir, "docs", "CODEOWNERS"),
+    path__default.default.join(rootDir, "CODEOWNERS")
+  ];
+  for (const p of possiblePaths) {
+    if (await fs__default.default.pathExists(p)) {
+      return p;
+    }
+  }
+  return void 0;
+}
+function isValidSingleOwnerId(id) {
+  if (!id || typeof id !== "string") {
+    return false;
+  }
+  return TEAM_ID_RE.test(id) || USER_ID_RE.test(id) || EMAIL_RE.test(id);
+}
+function parseOwnerIds(spaceSeparatedOwnerIds) {
+  if (!spaceSeparatedOwnerIds || typeof spaceSeparatedOwnerIds !== "string") {
+    return void 0;
+  }
+  const ids = spaceSeparatedOwnerIds.split(" ").filter(Boolean);
+  if (!ids.every(isValidSingleOwnerId)) {
+    return void 0;
+  }
+  return ids;
+}
+async function addCodeownersEntry(ownedPath, ownerStr, codeownersFilePath) {
+  const ownerIds = parseOwnerIds(ownerStr);
+  if (!ownerIds || ownerIds.length === 0) {
+    return false;
+  }
+  let filePath = codeownersFilePath;
+  if (!filePath) {
+    filePath = await getCodeownersFilePath(paths.paths.targetRoot);
+    if (!filePath) {
+      return false;
+    }
+  }
+  const allLines = (await fs__default.default.readFile(filePath, "utf8")).split("\n");
+  const commentLines = [];
+  for (const line of allLines) {
+    if (line[0] !== "#") {
+      break;
+    }
+    commentLines.push(line);
+  }
+  const oldDeclarationEntries = allLines.filter((line) => line[0] !== "#").map((line) => line.split(/\s+/).filter(Boolean)).filter((tokens) => tokens.length >= 2).map((tokens) => ({
+    ownedPath: tokens[0],
+    ownerIds: tokens.slice(1)
+  }));
+  const newDeclarationEntries = oldDeclarationEntries.filter((entry) => entry.ownedPath !== "*").concat([{ ownedPath, ownerIds }]).sort((l1, l2) => l1.ownedPath.localeCompare(l2.ownedPath));
+  newDeclarationEntries.unshift({
+    ownedPath: "*",
+    ownerIds: [DEFAULT_OWNER]
+  });
+  const longestOwnedPath = newDeclarationEntries.reduce(
+    (length, entry) => Math.max(length, entry.ownedPath.length),
+    0
+  );
+  const newDeclarationLines = newDeclarationEntries.map((entry) => {
+    const entryPath = entry.ownedPath + " ".repeat(longestOwnedPath - entry.ownedPath.length);
+    return [entryPath, ...entry.ownerIds].join(" ");
+  });
+  const newLines = [...commentLines, "", ...newDeclarationLines, ""];
+  await fs__default.default.writeFile(filePath, newLines.join("\n"), "utf8");
+  return true;
+}
+
+exports.addCodeownersEntry = addCodeownersEntry;
+exports.getCodeownersFilePath = getCodeownersFilePath;
+exports.isValidSingleOwnerId = isValidSingleOwnerId;
+exports.parseOwnerIds = parseOwnerIds;
+//# sourceMappingURL=codeowners.cjs.js.map

package/dist/{cjs/config-DBpmZirN.cjs.js → lib/config.cjs.js}

@@ -2,12 +2,12 @@
 
 var configLoader = require('@backstage/config-loader');
 var config = require('@backstage/config');
-var index = require('./index-b1ouG3q6.cjs.js');
+var paths = require('./paths.cjs.js');
 var getPackages = require('@manypkg/get-packages');
 var cliNode = require('@backstage/cli-node');
 
 async function loadCliConfig(options) {
-  const { packages } = await getPackages.getPackages(index.paths.targetDir);
+  const { packages } = await getPackages.getPackages(paths.paths.targetDir);
   let localPackageNames;
   if (options.fromPackage) {
     if (packages.length) {
@@ -29,15 +29,15 @@ async function loadCliConfig(options) {
   const schema = await configLoader.loadConfigSchema({
     dependencies: localPackageNames,
     // Include the package.json in the project root if it exists
-    packagePaths: [index.paths.resolveTargetRoot("package.json")],
+    packagePaths: [paths.paths.resolveTargetRoot("package.json")],
     noUndeclaredProperties: options.strict
   });
   const source = configLoader.ConfigSources.default({
     allowMissingDefaultConfig: true,
     substitutionFunc: options.mockEnv ? async (name) => process.env[name] || "x" : void 0,
     watch: Boolean(options.watch),
-    rootDir: index.paths.targetRoot,
-    argv: options.args.flatMap((t) => ["--config", index.paths.resolveTarget(t)])
+    rootDir: paths.paths.targetRoot,
+    argv: options.args.flatMap((t) => ["--config", paths.paths.resolveTarget(t)])
   });
   const appConfigs = await new Promise((resolve, reject) => {
     async function loadConfigReaderLoop() {
@@ -105,4 +105,4 @@ async function loadCliConfig(options) {
 }
 
 exports.loadCliConfig = loadCliConfig;
-//# sourceMappingURL=config-DBpmZirN.cjs.js.map
+//# sourceMappingURL=config.cjs.js.map

package/dist/{cjs/entryPoints-coip0t-x.cjs.js → lib/entryPoints.cjs.js}

@@ -44,4 +44,4 @@ function readEntryPoints(pkg) {
 }
 
 exports.readEntryPoints = readEntryPoints;
-//# sourceMappingURL=entryPoints-coip0t-x.cjs.js.map
+//# sourceMappingURL=entryPoints.cjs.js.map

package/dist/lib/errors.cjs.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var chalk = require('chalk');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+class CustomError extends Error {
+  get name() {
+    return this.constructor.name;
+  }
+}
+class ExitCodeError extends CustomError {
+  code;
+  constructor(code, command) {
+    super(
+      command ? `Command '${command}' exited with code ${code}` : `Child exited with code ${code}`
+    );
+    this.code = code;
+  }
+}
+function exitWithError(error) {
+  if (error instanceof ExitCodeError) {
+    process.stderr.write(`
+${chalk__default.default.red(error.message)}
+
+`);
+    process.exit(error.code);
+  } else {
+    process.stderr.write(`
+${chalk__default.default.red(`${error}`)}
+
+`);
+    process.exit(1);
+  }
+}
+class NotFoundError extends CustomError {
+}
+
+exports.CustomError = CustomError;
+exports.ExitCodeError = ExitCodeError;
+exports.NotFoundError = NotFoundError;
+exports.exitWithError = exitWithError;
+//# sourceMappingURL=errors.cjs.js.map

package/dist/lib/experimental/IpcServer.cjs.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var errors = require('@backstage/errors');
+
+const requestType = "@backstage/cli/channel/request";
+const responseType = "@backstage/cli/channel/response";
+class IpcServer {
+  #generation = 1;
+  #methods = /* @__PURE__ */ new Map();
+  addChild(child) {
+    const generation = this.#generation++;
+    const sendMessage = child.send?.bind(child);
+    if (!sendMessage) {
+      return;
+    }
+    const messageListener = (request) => {
+      if (request.type !== requestType) {
+        return;
+      }
+      const handler = this.#methods.get(request.method);
+      if (!handler) {
+        sendMessage({
+          type: responseType,
+          id: request.id,
+          error: {
+            name: "NotFoundError",
+            message: `No handler registered for method ${request.method}`
+          }
+        });
+        return;
+      }
+      Promise.resolve().then(() => handler(request.body, { generation })).then(
+        (response) => sendMessage({
+          type: responseType,
+          id: request.id,
+          body: response
+        })
+      ).catch(
+        (error) => sendMessage({
+          type: responseType,
+          id: request.id,
+          error: errors.serializeError(error)
+        })
+      );
+    };
+    child.addListener("message", messageListener);
+    child.addListener("exit", () => {
+      child.removeListener("message", messageListener);
+    });
+  }
+  registerMethod(method, handler) {
+    if (this.#methods.has(method)) {
+      throw new Error(`A handler is already registered for method ${method}`);
+    }
+    this.#methods.set(method, handler);
+  }
+}
+
+exports.IpcServer = IpcServer;
+//# sourceMappingURL=IpcServer.cjs.js.map

package/dist/lib/experimental/ServerDataStore.cjs.js

@@ -0,0 +1,36 @@
+'use strict';
+
+class ServerDataStore {
+  static bind(server) {
+    const store = /* @__PURE__ */ new Map();
+    server.registerMethod(
+      "DevDataStore.save",
+      async (request, { generation }) => {
+        const { key, data } = request;
+        if (!key) {
+          throw new Error("Key is required in DevDataStore.save");
+        }
+        const item = store.get(key);
+        if (!item) {
+          store.set(key, { generation, data });
+          return { saved: true };
+        }
+        if (item.generation > generation) {
+          return { saved: false };
+        }
+        store.set(key, { generation, data });
+        return { saved: true };
+      }
+    );
+    server.registerMethod(
+      "DevDataStore.load",
+      async (request) => {
+        const item = store.get(request.key);
+        return { loaded: Boolean(item), data: item?.data };
+      }
+    );
+  }
+}
+
+exports.ServerDataStore = ServerDataStore;
+//# sourceMappingURL=ServerDataStore.cjs.js.map

package/dist/lib/experimental/startBackendExperimental.cjs.js

@@ -0,0 +1,128 @@
+'use strict';
+
+var chokidar = require('chokidar');
+var ctrlcWindows = require('ctrlc-windows');
+var IpcServer = require('./IpcServer.cjs.js');
+var ServerDataStore = require('./ServerDataStore.cjs.js');
+var debounce = require('lodash/debounce');
+var url = require('url');
+var path = require('path');
+var paths = require('../paths.cjs.js');
+var spawn = require('cross-spawn');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var debounce__default = /*#__PURE__*/_interopDefaultCompat(debounce);
+var spawn__default = /*#__PURE__*/_interopDefaultCompat(spawn);
+
+const loaderArgs = [
+  "--enable-source-maps",
+  "--require",
+  require.resolve("@backstage/cli/config/nodeTransform.cjs")
+  // TODO: Support modules, although there's currently no way to load them since import() is transpiled tp require()
+];
+async function startBackendExperimental(options) {
+  const envEnv = process.env;
+  if (!envEnv.NODE_ENV) {
+    envEnv.NODE_ENV = "development";
+  }
+  const server = new IpcServer.IpcServer();
+  ServerDataStore.ServerDataStore.bind(server);
+  let exiting = false;
+  let firstStart = true;
+  let child;
+  let watcher = void 0;
+  let shutdownPromise = void 0;
+  const watchedPaths = /* @__PURE__ */ new Set();
+  const restart = debounce__default.default(async () => {
+    if (firstStart) {
+      firstStart = false;
+    } else {
+      console.log();
+      console.log("Change detected, restarting the development server...");
+      console.log();
+    }
+    if (shutdownPromise) {
+      return;
+    }
+    if (child && !child.killed && child.exitCode === null) {
+      shutdownPromise = new Promise((resolve) => child.once("exit", resolve));
+      if (process.platform === "win32" && child.pid) {
+        ctrlcWindows.ctrlc(child.pid);
+      } else {
+        child.kill();
+      }
+      await shutdownPromise;
+      shutdownPromise = void 0;
+    }
+    if (exiting) {
+      return;
+    }
+    const optionArgs = new Array();
+    if (options.inspectEnabled) {
+      const inspect = typeof options.inspectEnabled === "string" ? `--inspect=${options.inspectEnabled}` : "--inspect";
+      optionArgs.push(inspect);
+    } else if (options.inspectBrkEnabled) {
+      const inspect = typeof options.inspectBrkEnabled === "string" ? `--inspect-brk=${options.inspectBrkEnabled}` : "--inspect-brk";
+      optionArgs.push(inspect);
+    }
+    if (options.require) {
+      optionArgs.push(`--require=${options.require}`);
+    }
+    const userArgs = process.argv.slice(["node", "backstage-cli", "package", "start"].length).filter((arg) => !optionArgs.includes(arg));
+    child = spawn__default.default(
+      process.execPath,
+      [...loaderArgs, ...optionArgs, options.entry, ...userArgs],
+      {
+        stdio: ["ignore", "inherit", "inherit", "ipc"],
+        env: {
+          ...process.env,
+          BACKSTAGE_CLI_CHANNEL: "1",
+          ESBK_TSCONFIG_PATH: paths.paths.resolveTargetRoot("tsconfig.json")
+        },
+        serialization: "advanced"
+      }
+    );
+    server.addChild(child);
+    child.on("message", (data) => {
+      if (!watcher) {
+        return;
+      }
+      if (typeof data === "object" && data?.type === "watch") {
+        let path$1 = data.path;
+        if (path$1.startsWith("file:")) {
+          path$1 = url.fileURLToPath(path$1);
+        }
+        if (path.isAbsolute(path$1) && !watchedPaths.has(path$1)) {
+          watchedPaths.add(path$1);
+          watcher.add(path$1);
+        }
+      }
+    });
+  }, 100);
+  restart();
+  watcher = chokidar.watch(["./package.json"], {
+    cwd: process.cwd(),
+    ignoreInitial: true,
+    ignorePermissionErrors: true
+  }).on("all", restart);
+  process.stdin.on("data", restart);
+  const exitPromise = new Promise((resolveExitPromise) => {
+    async function handleSignal(signal) {
+      exiting = true;
+      if (child && child.exitCode === null) {
+        await new Promise((resolve) => {
+          child.on("close", resolve);
+          child.kill(signal);
+        });
+      }
+      resolveExitPromise();
+    }
+    process.once("SIGINT", handleSignal);
+    process.once("SIGTERM", handleSignal);
+  });
+  return () => exitPromise;
+}
+
+exports.startBackendExperimental = startBackendExperimental;
+//# sourceMappingURL=startBackendExperimental.cjs.js.map

package/dist/lib/new/FactoryRegistry.cjs.js

@@ -0,0 +1,96 @@
+'use strict';
+
+var chalk = require('chalk');
+var inquirer = require('inquirer');
+var index = require('./factories/index.cjs.js');
+var partition = require('lodash/partition');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
+var partition__default = /*#__PURE__*/_interopDefaultCompat(partition);
+
+function applyPromptMessageTransforms(prompt, transforms) {
+  return {
+    ...prompt,
+    message: prompt.message && (async (answers) => {
+      if (typeof prompt.message === "function") {
+        return transforms.message(await prompt.message(answers));
+      }
+      return transforms.message(await prompt.message);
+    }),
+    validate: prompt.validate && (async (...args) => {
+      const result = await prompt.validate(...args);
+      if (typeof result === "string") {
+        return transforms.error(result);
+      }
+      return result;
+    })
+  };
+}
+class FactoryRegistry {
+  static factoryMap = new Map(
+    Object.values(index).map((factory) => [factory.name, factory])
+  );
+  static async interactiveSelect(preselected) {
+    let selected = preselected;
+    if (!selected) {
+      const answers = await inquirer__default.default.prompt([
+        {
+          type: "list",
+          name: "name",
+          message: "What do you want to create?",
+          choices: Array.from(this.factoryMap.values()).map((factory2) => ({
+            name: `${factory2.name} - ${factory2.description}`,
+            value: factory2.name
+          }))
+        }
+      ]);
+      selected = answers.name;
+    }
+    const factory = this.factoryMap.get(selected);
+    if (!factory) {
+      throw new Error(`Unknown selection '${selected}'`);
+    }
+    return factory;
+  }
+  static async populateOptions(factory, provided) {
+    let currentOptions = provided;
+    if (factory.optionsDiscovery) {
+      const discoveredOptions = await factory.optionsDiscovery();
+      currentOptions = {
+        ...currentOptions,
+        ...discoveredOptions
+      };
+    }
+    if (factory.optionsPrompts) {
+      const [hasAnswers, needsAnswers] = partition__default.default(
+        factory.optionsPrompts,
+        (option) => option.name in currentOptions
+      );
+      for (const option of hasAnswers) {
+        const value = provided[option.name];
+        if (option.validate) {
+          const result = option.validate(value);
+          if (result !== true) {
+            throw new Error(`Invalid option '${option.name}'. ${result}`);
+          }
+        }
+      }
+      currentOptions = await inquirer__default.default.prompt(
+        needsAnswers.map(
+          (option) => applyPromptMessageTransforms(option, {
+            message: chalk__default.default.blue,
+            error: chalk__default.default.red
+          })
+        ),
+        currentOptions
+      );
+    }
+    return currentOptions;
+  }
+}
+
+exports.FactoryRegistry = FactoryRegistry;
+//# sourceMappingURL=FactoryRegistry.cjs.js.map

package/dist/lib/new/factories/backendModule.cjs.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var fs = require('fs-extra');
+var chalk = require('chalk');
+var camelCase = require('lodash/camelCase');
+var paths = require('../../paths.cjs.js');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var types = require('../types.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+var prompts = require('./common/prompts.cjs.js');
+var tasks$1 = require('./common/tasks.cjs.js');
+var util = require('./common/util.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var camelCase__default = /*#__PURE__*/_interopDefaultCompat(camelCase);
+
+const backendModule = types.createFactory({
+  name: "backend-module",
+  description: "A new backend module that extends an existing backend plugin with additional features",
+  optionsDiscovery: async () => ({
+    codeOwnersPath: await codeowners.getCodeownersFilePath(paths.paths.targetRoot)
+  }),
+  optionsPrompts: [prompts.pluginIdPrompt(), prompts.moduleIdIdPrompt(), prompts.ownerPrompt()],
+  async create(options, ctx) {
+    const { id: pluginId, moduleId } = options;
+    const dirName = `${pluginId}-backend-module-${moduleId}`;
+    const name = util.resolvePackageName({
+      baseName: dirName,
+      scope: ctx.scope,
+      plugin: true
+    });
+    tasks.Task.log();
+    tasks.Task.log(`Creating backend module ${chalk__default.default.cyan(name)}`);
+    const targetDir = ctx.isMonoRepo ? paths.paths.resolveTargetRoot("plugins", dirName) : paths.paths.resolveTargetRoot(`backstage-plugin-${dirName}`);
+    const moduleCamelCase = camelCase__default.default(moduleId);
+    const modulePascalCase = moduleCamelCase[0].toUpperCase() + moduleCamelCase.slice(1);
+    const moduleVar = `${camelCase__default.default(pluginId)}Module${modulePascalCase}`;
+    await tasks$1.executePluginPackageTemplate(ctx, {
+      targetDir,
+      templateName: "default-backend-module",
+      values: {
+        pluginId,
+        moduleId,
+        name,
+        moduleVar,
+        packageVersion: ctx.defaultVersion,
+        privatePackage: ctx.private,
+        npmRegistry: ctx.npmRegistry,
+        license: ctx.license
+      }
+    });
+    if (await fs__default.default.pathExists(paths.paths.resolveTargetRoot("packages/backend"))) {
+      await tasks.Task.forItem("backend", "adding dependency", async () => {
+        await tasks.addPackageDependency(
+          paths.paths.resolveTargetRoot("packages/backend/package.json"),
+          {
+            dependencies: {
+              [name]: `^${ctx.defaultVersion}`
+            }
+          }
+        );
+      });
+    }
+    await tasks.addToBackend(name, {
+      type: "module"
+    });
+    if (options.owner) {
+      await codeowners.addCodeownersEntry(`/plugins/${dirName}`, options.owner);
+    }
+    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await tasks.Task.forCommand("yarn lint --fix", {
+      cwd: targetDir,
+      optional: true
+    });
+  }
+});
+
+exports.backendModule = backendModule;
+//# sourceMappingURL=backendModule.cjs.js.map

package/dist/lib/new/factories/backendPlugin.cjs.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var fs = require('fs-extra');
+var chalk = require('chalk');
+var camelCase = require('lodash/camelCase');
+var paths = require('../../paths.cjs.js');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var types = require('../types.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+var prompts = require('./common/prompts.cjs.js');
+var tasks$1 = require('./common/tasks.cjs.js');
+var util = require('./common/util.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var camelCase__default = /*#__PURE__*/_interopDefaultCompat(camelCase);
+
+const backendPlugin = types.createFactory({
+  name: "backend-plugin",
+  description: "A new backend plugin",
+  optionsDiscovery: async () => ({
+    codeOwnersPath: await codeowners.getCodeownersFilePath(paths.paths.targetRoot)
+  }),
+  optionsPrompts: [prompts.pluginIdPrompt(), prompts.ownerPrompt()],
+  async create(options, ctx) {
+    const { id } = options;
+    const pluginId = `${id}-backend`;
+    const name = util.resolvePackageName({
+      baseName: pluginId,
+      scope: ctx.scope,
+      plugin: true
+    });
+    tasks.Task.log();
+    tasks.Task.log(`Creating backend plugin ${chalk__default.default.cyan(name)}`);
+    const targetDir = ctx.isMonoRepo ? paths.paths.resolveTargetRoot("plugins", pluginId) : paths.paths.resolveTargetRoot(`backstage-plugin-${pluginId}`);
+    await tasks$1.executePluginPackageTemplate(ctx, {
+      targetDir,
+      templateName: "default-backend-plugin",
+      values: {
+        id,
+        name,
+        pluginVar: `${camelCase__default.default(id)}Plugin`,
+        pluginVersion: ctx.defaultVersion,
+        privatePackage: ctx.private,
+        npmRegistry: ctx.npmRegistry,
+        license: ctx.license
+      }
+    });
+    if (await fs__default.default.pathExists(paths.paths.resolveTargetRoot("packages/backend"))) {
+      await tasks.Task.forItem("backend", "adding dependency", async () => {
+        await tasks.addPackageDependency(
+          paths.paths.resolveTargetRoot("packages/backend/package.json"),
+          {
+            dependencies: {
+              [name]: `^${ctx.defaultVersion}`
+            }
+          }
+        );
+      });
+    }
+    await tasks.addToBackend(name, {
+      type: "plugin"
+    });
+    if (options.owner) {
+      await codeowners.addCodeownersEntry(`/plugins/${id}`, options.owner);
+    }
+    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await tasks.Task.forCommand("yarn lint --fix", {
+      cwd: targetDir,
+      optional: true
+    });
+  }
+});
+
+exports.backendPlugin = backendPlugin;
+//# sourceMappingURL=backendPlugin.cjs.js.map