pepr 0.52.2 → 0.52.3-nightly.1

package/src/cli/{build.helpers.ts → build/build.helpers.ts}

@@ -1,23 +1,24 @@
-import { createDirectoryIfNotExists } from "../lib/filesystemService";
-import { sanitizeResourceName } from "../sdk/sdk";
-import { createDockerfile } from "../lib/included-files";
+import { createDirectoryIfNotExists } from "../../lib/filesystemService";
+import { sanitizeResourceName } from "../../sdk/sdk";
+import { createDockerfile } from "../../lib/included-files";
 import { execSync } from "child_process";
-import { CapabilityExport } from "../lib/types";
-import { validateCapabilityNames } from "../lib/helpers";
-import { BuildOptions, BuildResult, context, BuildContext } from "esbuild";
-import { Assets } from "../lib/assets/assets";
+import { CapabilityExport } from "../../lib/types";
+import { validateCapabilityNames } from "../../lib/helpers";
+import { BuildOptions, context, BuildContext } from "esbuild";
+import { Assets } from "../../lib/assets/assets";
 import { resolve } from "path";
 import { promises as fs } from "fs";
-import { generateAllYaml } from "../lib/assets/yaml/generateAllYaml";
-import { webhookConfigGenerator } from "../lib/assets/webhooks";
-import { generateZarfYamlGeneric } from "../lib/assets/yaml/generateZarfYaml";
+import { generateAllYaml } from "../../lib/assets/yaml/generateAllYaml";
+import { webhookConfigGenerator } from "../../lib/assets/webhooks";
+import { generateZarfYamlGeneric } from "../../lib/assets/yaml/generateZarfYaml";
 import {
   getDeployment,
   getModuleSecret,
   getWatcher,
   service,
   watcherService,
-} from "../lib/assets/k8sObjects";
+} from "../../lib/assets/k8sObjects";
+import { Reloader } from "../types";
 
 interface ImageOptions {
   customImage?: string;
@@ -47,7 +48,6 @@ export function assignImage(imageOptions: ImageOptions): string {
   return "";
 }
 
-export type Reloader = (opts: BuildResult<BuildOptions>) => void | Promise<void>;
 /**
  * Determine the RBAC mode based on the CLI options and the module's config
  * @param opts CLI options
@@ -113,15 +113,9 @@ export function checkIronBankImage(registry: string, image: string, peprVersion:
  * @param imagePullSecret
  * @returns boolean
  */
-export function validImagePullSecret(imagePullSecretName: string): void {
-  if (imagePullSecretName) {
-    const error = "Invalid imagePullSecret. Please provide a valid name as defined in RFC 1123.";
-    if (sanitizeResourceName(imagePullSecretName) !== imagePullSecretName) {
-      // https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names
-      console.error(error);
-      process.exit(1);
-    }
-  }
+export function validImagePullSecret(imagePullSecretName: string): boolean {
+  // https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names
+  return sanitizeResourceName(imagePullSecretName) === imagePullSecretName;
 }
 
 /**

package/src/cli/build/buildModule.ts

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+
+import { execFileSync } from "child_process";
+import { BuildOptions, analyzeMetafile } from "esbuild";
+import { basename, extname, resolve } from "path";
+import { dependencies } from "../init/templates";
+import { peprFormat } from "../format";
+import { watchForChanges } from "./build.helpers";
+import { PeprConfig, Reloader } from "../types";
+import { BuildContext } from "esbuild";
+import { loadModule } from "./loadModule";
+
+export type BuildModuleReturn = {
+  ctx: BuildContext<BuildOptions>;
+  path: string;
+  cfg: PeprConfig;
+  uuid: string;
+};
+// Create a list of external libraries to exclude from the bundle, these are already stored in the container
+const externalLibs = Object.keys(dependencies);
+
+// Add the pepr library to the list of external libraries
+externalLibs.push("pepr");
+
+// Add the kubernetes client to the list of external libraries as it is pulled in by kubernetes-fluent-client
+externalLibs.push("@kubernetes/client-node");
+
+export async function buildModule(
+  outputDir: string,
+  reloader?: Reloader,
+  entryPoint = "pepr.ts",
+  embed = true,
+): Promise<BuildModuleReturn | void> {
+  try {
+    const { cfg, modulePath, path, uuid } = await loadModule(outputDir, entryPoint);
+
+    await checkFormat();
+    // Resolve node_modules folder (in support of npm workspaces!)
+    const npmRoot = execFileSync("npm", ["root"]).toString().trim();
+
+    // Run `tsc` to validate the module's types & output sourcemaps
+    const args = ["--project", `${modulePath}/tsconfig.json`, "--outdir", outputDir];
+    execFileSync(`${npmRoot}/.bin/tsc`, args);
+
+    // Common build options for all builds
+    const ctxCfg: BuildOptions = {
+      bundle: true,
+      entryPoints: [entryPoint],
+      external: externalLibs,
+      format: "cjs",
+      keepNames: true,
+      legalComments: "external",
+      metafile: true,
+      minify: true,
+      outfile: path,
+      plugins: [
+        {
+          name: "reload-server",
+          setup(build): void | Promise<void> {
+            build.onEnd(async r => {
+              // Print the build size analysis
+              if (r?.metafile) {
+                console.info(await analyzeMetafile(r.metafile));
+              }
+
+              // If we're in dev mode, call the reloader function
+              if (reloader) {
+                await reloader(r);
+              }
+            });
+          },
+        },
+      ],
+      platform: "node",
+      sourcemap: true,
+      treeShaking: true,
+    };
+
+    if (reloader) {
+      // Only minify the code if we're not in dev mode
+      ctxCfg.minify = false;
+    }
+
+    // If not embedding (i.e. making a library module to be distro'd via NPM)
+    if (!embed) {
+      // Don't minify
+      ctxCfg.minify = false;
+
+      // Preserve the original file name
+      ctxCfg.outfile = resolve(outputDir, basename(entryPoint, extname(entryPoint))) + ".js";
+
+      // Don't bundle
+      ctxCfg.packages = "external";
+
+      // Don't tree shake
+      ctxCfg.treeShaking = false;
+    }
+
+    const ctx = await watchForChanges(ctxCfg, reloader);
+
+    return { ctx, path, cfg, uuid };
+  } catch (e) {
+    handleModuleBuildError(e);
+  }
+}
+
+interface BuildModuleResult {
+  stdout?: Buffer;
+  stderr: Buffer;
+}
+
+function handleModuleBuildError(e: BuildModuleResult): void {
+  console.error(`Error building module:`, e);
+
+  if (!e.stdout) process.exit(1); // Exit with a non-zero exit code on any other error
+
+  const out = e.stdout.toString() as string;
+  const err = e.stderr.toString();
+
+  console.info(out);
+  console.error(err);
+
+  // Check for version conflicts
+  if (out.includes("Types have separate declarations of a private property '_name'.")) {
+    // Try to find the conflicting package
+    const pgkErrMatch = /error TS2322: .*? 'import\("\/.*?\/node_modules\/(.*?)\/node_modules/g;
+    out.matchAll(pgkErrMatch);
+
+    // Look for package conflict errors
+    const conflicts = [...out.matchAll(pgkErrMatch)];
+
+    // If the regex didn't match, leave a generic error
+    if (conflicts.length < 1) {
+      console.info(
+        `\n\tOne or more imported Pepr Capabilities seem to be using an incompatible version of Pepr.\n\tTry updating your Pepr Capabilities to their latest versions.`,
+        "Version Conflict",
+      );
+    }
+
+    // Otherwise, loop through each conflicting package and print an error
+    conflicts.forEach(match => {
+      console.info(
+        `\n\tPackage '${match[1]}' seems to be incompatible with your current version of Pepr.\n\tTry updating to the latest version.`,
+        "Version Conflict",
+      );
+    });
+  }
+}
+
+async function checkFormat(): Promise<void> {
+  const validFormat = await peprFormat(true);
+
+  if (!validFormat) {
+    console.info(
+      "\x1b[33m%s\x1b[0m",
+      "Formatting errors were found. The build will continue, but you may want to run `npx pepr format` to address any issues.",
+    );
+  }
+}

package/src/cli/build/index.ts

@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+
+import { Assets } from "../../lib/assets/assets";
+import { Command } from "commander";
+import { Option } from "commander";
+import { parseTimeout } from "../../lib/helpers";
+import {
+  determineRbacMode,
+  assignImage,
+  createOutputDirectory,
+  handleValidCapabilityNames,
+  handleCustomImageBuild,
+  validImagePullSecret,
+  generateYamlAndWriteToDisk,
+} from "./build.helpers";
+import { buildModule } from "./buildModule";
+import Log from "../../lib/telemetry/logger";
+
+export default function (program: Command): void {
+  program
+    .command("build")
+    .description("Build a Pepr Module for deployment")
+    .addOption(
+      new Option("-M, --rbac-mode <mode>", "Override module config and set RBAC mode.").choices([
+        "admin",
+        "scoped",
+      ]),
+    )
+    .addOption(
+      new Option(
+        "-I, --registry-info <registry/username>",
+        "Provide the image registry and username for building and pushing a custom WASM container. Requires authentication. Conflicts with --custom-image and --registry. Builds and pushes `'<registry/username>/custom-pepr-controller:<current-version>'`.",
+      ).conflicts(["customImage", "registry"]),
+    )
+    .option("-P, --with-pull-secret <name>", "Use image pull secret for controller Deployment.", "")
+    .addOption(
+      new Option(
+        "-c, --custom-name <name>",
+        "Set name for zarf component and service monitors in helm charts.",
+      ),
+    )
+    .option("-e, --entry-point <file>", "Specify the entry point file to build with.", "pepr.ts")
+    .addOption(
+      new Option(
+        "-i, --custom-image <image>",
+        "Specify a custom image with version for deployments. Conflicts with --registry-info and --registry. Example: 'docker.io/username/custom-pepr-controller:v1.0.0'",
+      ).conflicts(["registryInfo", "registry"]),
+    )
+    .option(
+      "-n, --no-embed",
+      "Disable embedding of deployment files into output module. Useful when creating library modules intended solely for reuse/distribution via NPM.",
+    )
+    .option("-o, --output <directory>", "Set output directory.", "dist")
+    .addOption(
+      new Option(
+        "-r, --registry <registry>",
+        "Container registry: Choose container registry for deployment manifests. Conflicts with --custom-image and --registry-info.",
+      )
+        .conflicts(["customImage", "registryInfo"])
+        .choices(["GitHub", "Iron Bank"]),
+    )
+    .option(
+      "-t, --timeout <seconds>",
+      "How long the API server should wait for a webhook to respond before treating the call as a failure.",
+      parseTimeout,
+    )
+    .addOption(
+      new Option("-z, --zarf <manifest|chart>", "Set Zarf package type")
+        .choices(["manifest", "chart"])
+        .default("manifest"),
+    )
+    .action(async opts => {
+      const outputDir = await createOutputDirectory(opts.output);
+
+      // Build the module
+      const buildModuleResult = await buildModule(
+        outputDir,
+        undefined,
+        opts.entryPoint,
+        opts.embed,
+      );
+
+      const { cfg, path } = buildModuleResult!;
+      // override the name if provided
+      if (opts.customName) {
+        process.env.PEPR_CUSTOM_BUILD_NAME = opts.customName;
+      }
+
+      const image = assignImage({
+        customImage: opts.customImage,
+        registryInfo: opts.registryInfo,
+        peprVersion: cfg.pepr.peprVersion,
+        registry: opts.registry,
+      });
+
+      // Check if there is a custom timeout defined
+      if (opts.timeout !== undefined) {
+        cfg.pepr.webhookTimeout = opts.timeout;
+      }
+
+      if (opts.registryInfo !== undefined) {
+        Log.info(`Including ${cfg.pepr.includedFiles.length} files in controller image.`);
+        // for journey test to make sure the image is built
+
+        // only actually build/push if there are files to include
+        await handleCustomImageBuild(
+          cfg.pepr.includedFiles,
+          cfg.pepr.peprVersion,
+          cfg.description,
+          image,
+        );
+      }
+
+      // If building without embedding, exit after building
+      if (!opts.embed) {
+        Log.info(`Module built successfully at ${path}`);
+        return;
+      }
+
+      // Generate a secret for the module
+      const assets = new Assets(
+        {
+          ...cfg.pepr,
+          appVersion: cfg.version,
+          description: cfg.description,
+          alwaysIgnore: {
+            namespaces: cfg.pepr.alwaysIgnore?.namespaces,
+          },
+          // Can override the rbacMode with the CLI option
+          rbacMode: determineRbacMode(opts, cfg),
+        },
+        path,
+        opts.withPullSecret === "" ? [] : [opts.withPullSecret],
+      );
+
+      if (image !== "") assets.image = image;
+
+      // Ensure imagePullSecret is valid
+      if (!validImagePullSecret(opts.withPullSecret)) {
+        throw new Error(
+          "Invalid imagePullSecret. Please provide a valid name as defined in RFC 1123.",
+        );
+      }
+
+      handleValidCapabilityNames(assets.capabilities);
+      await generateYamlAndWriteToDisk({
+        uuid: cfg.pepr.uuid,
+        outputDir,
+        imagePullSecret: opts.withPullSecret,
+        zarf: opts.zarf,
+        assets,
+      });
+    });
+}

package/src/cli/build/loadModule.ts

@@ -0,0 +1,54 @@
+import fs from "fs/promises";
+import { resolve, dirname } from "path/posix";
+import { version } from "../init/templates";
+import { PeprConfig } from "../types";
+
+export type LoadModuleReturn = {
+  cfg: PeprConfig;
+  entryPointPath: string;
+  modulePath: string;
+  name: string;
+  path: string;
+  uuid: string;
+};
+
+export async function loadModule(outputDir: string, entryPoint: string): Promise<LoadModuleReturn> {
+  // Resolve path to the module / files
+  const entryPointPath = resolve(".", entryPoint);
+  const modulePath = dirname(entryPointPath);
+  const cfgPath = resolve(modulePath, "package.json");
+
+  // Ensure the module's package.json and entrypoint files exist
+  try {
+    await fs.access(cfgPath);
+    await fs.access(entryPointPath);
+  } catch {
+    console.error(
+      `Could not find ${cfgPath} or ${entryPointPath} in the current directory. Please run this command from the root of your module's directory.`,
+    );
+    process.exit(1);
+  }
+
+  // Read the module's UUID from the package.json file
+  const moduleText = await fs.readFile(cfgPath, { encoding: "utf-8" });
+  const cfg = JSON.parse(moduleText);
+  const { uuid } = cfg.pepr;
+  const name = `pepr-${uuid}.js`;
+
+  // Set the Pepr version from the current running version
+  cfg.pepr.peprVersion = version;
+
+  // Exit if the module's UUID could not be found
+  if (!uuid) {
+    throw new Error("Could not load the uuid in package.json");
+  }
+
+  return {
+    cfg,
+    entryPointPath,
+    modulePath,
+    name,
+    path: resolve(outputDir, name),
+    uuid,
+  };
+}

package/src/cli/crd/generate/generators.ts

@@ -16,7 +16,7 @@ import { kind as k } from "kubernetes-fluent-client";
 import { V1JSONSchemaProps } from "@kubernetes/client-node";
 import { WarningMessages, ErrorMessages } from "./messages";
 
-export function extractCRDDetails(
+function extractCRDDetails(
   content: string,
   sourceFile: SourceFile,
 ): {
@@ -145,7 +145,7 @@ export function extractDetails(sourceFile: SourceFile): {
   throw new Error(ErrorMessages.INVALID_SCOPE(scope));
 }
 
-export function getJsDocDescription(node: Node): string {
+function getJsDocDescription(node: Node): string {
   if (!Node.isPropertySignature(node) && !Node.isPropertyDeclaration(node)) return "";
   return node
     .getJsDocs()
@@ -155,7 +155,7 @@ export function getJsDocDescription(node: Node): string {
     .trim();
 }
 
-export function getSchemaFromType(decl: InterfaceDeclaration | TypeAliasDeclaration): {
+function getSchemaFromType(decl: InterfaceDeclaration | TypeAliasDeclaration): {
   properties: Record<string, V1JSONSchemaProps>;
   required: string[];
 } {
@@ -183,7 +183,7 @@ export function getSchemaFromType(decl: InterfaceDeclaration | TypeAliasDeclarat
   return { properties, required };
 }
 
-export function mapTypeToSchema(type: Type): V1JSONSchemaProps {
+function mapTypeToSchema(type: Type): V1JSONSchemaProps {
   if (type.getText() === "Date") return { type: "string", format: "date-time" };
   if (type.isString()) return { type: "string" };
   if (type.isNumber()) return { type: "number" };
@@ -199,7 +199,7 @@ export function mapTypeToSchema(type: Type): V1JSONSchemaProps {
   return { type: "string" };
 }
 
-export function buildObjectSchema(type: Type): V1JSONSchemaProps {
+function buildObjectSchema(type: Type): V1JSONSchemaProps {
   const props: Record<string, V1JSONSchemaProps> = {};
   const required: string[] = [];
 
@@ -249,7 +249,7 @@ interface CRDConfig {
   conditionSchema: ReturnType<typeof getSchemaFromType>;
 }
 
-export function buildCRD(config: CRDConfig): k.CustomResourceDefinition {
+function buildCRD(config: CRDConfig): k.CustomResourceDefinition {
   return {
     apiVersion: "apiextensions.k8s.io/v1",
     kind: "CustomResourceDefinition",

package/src/cli/deploy/buildAndDeploy.ts

@@ -0,0 +1,48 @@
+import { Assets } from "../../lib/assets/assets";
+import { deployWebhook } from "../../lib/assets/deploy";
+import { loadCapabilities } from "../../lib/assets/loader";
+import { namespaceDeploymentsReady } from "../../lib/deploymentChecks";
+import { namespaceComplianceValidator, validateCapabilityNames } from "../../lib/helpers";
+import { CapabilityExport } from "../../lib/types";
+import { buildModule } from "../build/buildModule";
+
+export async function buildAndDeployModule(image: string, force: boolean): Promise<void> {
+  const builtModule = await buildModule("dist");
+  if (!builtModule) {
+    return;
+  }
+
+  // Generate a secret for the module
+  const webhook = new Assets(
+    { ...builtModule.cfg.pepr, description: builtModule.cfg.description },
+    builtModule.path,
+    [],
+  );
+  webhook.image = image ?? webhook.image;
+  const capabilities = await loadCapabilities(webhook.path);
+  for (const capability of capabilities) {
+    validateNamespaces(capability, webhook);
+  }
+  try {
+    await webhook.deploy(deployWebhook, force, builtModule.cfg.pepr.webhookTimeout ?? 10);
+
+    // wait for capabilities to be loaded and test names
+    validateCapabilityNames(webhook.capabilities);
+
+    // Wait for the pepr-system resources to be fully up
+    await namespaceDeploymentsReady();
+    console.info(`Module deployed successfully`);
+  } catch (e) {
+    console.error(`Error deploying module:`, e);
+    process.exit(1);
+  }
+}
+export function validateNamespaces(capability: CapabilityExport, webhook: Assets): void {
+  namespaceComplianceValidator(capability, webhook.alwaysIgnore?.namespaces);
+  namespaceComplianceValidator(
+    capability,
+    webhook.config.admission?.alwaysIgnore?.namespaces,
+    false,
+  );
+  namespaceComplianceValidator(capability, webhook.config.watch?.alwaysIgnore?.namespaces, true);
+}

package/src/cli/deploy/imagePullSecret.ts

@@ -0,0 +1,68 @@
+import { ImagePullSecret } from "../../lib/types";
+import { sanitizeName } from "../init/utils";
+
+export interface ImagePullSecretDetails {
+  pullSecret?: string;
+  dockerServer?: string;
+  dockerUsername?: string;
+  dockerEmail?: string;
+  dockerPassword?: string;
+}
+
+export function validateImagePullSecretDetails(details: ImagePullSecretDetails): {
+  valid: boolean;
+  error?: string;
+} {
+  if (!details.pullSecret) {
+    return { valid: true };
+  }
+
+  // https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names
+  if (details.pullSecret !== sanitizeName(details.pullSecret)) {
+    return {
+      valid: false,
+      error: `Invalid --pullSecret. Must be valid name as defined in RFC 1123.`,
+    };
+  }
+
+  const missing: string[] = [];
+  if (!details.dockerEmail) {
+    missing.push("--docker-email");
+  }
+  if (!details.dockerServer) {
+    missing.push("--docker-server");
+  }
+  if (!details.dockerUsername) {
+    missing.push("--docker-username");
+  }
+  if (!details.dockerPassword) {
+    missing.push("--docker-password");
+  }
+
+  if (missing.length > 0) {
+    return {
+      valid: false,
+      error: `Error: Must provide ${missing.join(", ")} when providing --pull-secret`,
+    };
+  }
+
+  return { valid: true };
+}
+
+type ValidatedImagePullSecretDetails = Required<ImagePullSecretDetails>;
+
+export function generateImagePullSecret(details: ValidatedImagePullSecretDetails): ImagePullSecret {
+  const auth = Buffer.from(`${details.dockerUsername}:${details.dockerPassword}`).toString(
+    "base64",
+  );
+  return {
+    auths: {
+      [details.dockerServer]: {
+        username: details.dockerUsername,
+        password: details.dockerPassword,
+        email: details.dockerEmail,
+        auth,
+      },
+    },
+  };
+}

package/src/cli/deploy/index.ts

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Pepr Authors
+
+import { Command } from "commander";
+import { deployImagePullSecret } from "../../lib/assets/deploy";
+import { validateImagePullSecretDetails, generateImagePullSecret } from "./imagePullSecret";
+import { getUserConfirmation } from "./userConfirmation";
+import { buildAndDeployModule } from "./buildAndDeploy";
+
+export default function (program: Command): void {
+  program
+    .command("deploy")
+    .description("Deploy a Pepr Module")
+    .option("-E, --docker-email <email>", "Email for Docker registry.")
+    .option("-P, --docker-password <password>", "Password for Docker registry.")
+    .option("-S, --docker-server <server>", "Docker server address.")
+    .option("-U, --docker-username <username>", "Docker registry username.")
+    .option("-f, --force", "Force deploy the module, override manager field.")
+    .option("-i, --image <image>", "Override the image tag.")
+    .option("-p, --pull-secret <name>", "Deploy imagePullSecret for Controller private registry.")
+    .option("-y, --yes", "Skip confirmation prompts.")
+    .action(async opts => {
+      const valResp = validateImagePullSecretDetails(opts);
+      if (!valResp.valid) {
+        console.error(valResp.error);
+        process.exit(1);
+      }
+
+      if (opts.pullSecret) {
+        await deployImagePullSecret(generateImagePullSecret(opts), opts.pullSecret);
+        return;
+      }
+
+      if (!(await getUserConfirmation(opts))) {
+        process.exit(0);
+      }
+
+      await buildAndDeployModule(opts.image, opts.force);
+    });
+}

package/src/cli/deploy/userConfirmation.ts

@@ -0,0 +1,16 @@
+import prompt from "prompts";
+
+export async function getUserConfirmation(opts: { yes: boolean }): Promise<boolean> {
+  if (opts.yes) {
+    return true;
+  }
+
+  // Prompt the user to confirm
+  const confirmation = await prompt({
+    type: "confirm",
+    name: "yes",
+    message: "This will remove and redeploy the module. Continue?",
+  });
+
+  return confirmation.yes ? true : false;
+}

package/src/cli/dev.ts

@@ -7,7 +7,8 @@ import { ChildProcess, fork } from "child_process";
 import { K8s, kind } from "kubernetes-fluent-client";
 import { Command } from "commander";
 import { Store } from "../lib/k8s";
-import { buildModule, loadModule } from "./build";
+import { buildModule } from "./build/buildModule";
+import { loadModule } from "./build/loadModule";
 import { deployWebhook } from "../lib/assets/deploy";
 import { promises as fs } from "fs";
 import { validateCapabilityNames } from "../lib/helpers";
@@ -35,7 +36,7 @@ export default function (program: Command): void {
       }
 
       // Build the module
-      const { cfg, path } = await loadModule();
+      const { cfg, path } = await loadModule("dist", "pepr.ts");
 
       // Generate a secret for the module
       const webhook = new Assets(
@@ -103,7 +104,7 @@ export default function (program: Command): void {
           });
         };
 
-        await buildModule(async r => {
+        await buildModule("dist", async r => {
           if (r.errors.length > 0) {
             console.error(`Error compiling module: ${r.errors}`);
             return;