create-nexgen 1.0.4

package/template/src/framework/facade.ts

@@ -0,0 +1,27 @@
+/**
+ * Why: Central public API surface for framework consumers.
+ * When: Modules/middlewares need framework utilities.
+ * Where: App-layer imports should target this file.
+ * How: Re-exports stable, reusable helpers while hiding setup internals.
+ */
+export { cache } from "@/framework/cache/cache.js";
+export { db, database } from "@/framework/database/connection.js";
+export { paginate, paginateQuery, paginateTable, type PaginatedResult } from "@/framework/database/paginate.js";
+export { command, dispatchCommand, dispatchEvent } from "@/framework/events/dispatcher.js";
+export { createRouter, group } from "@/framework/http/router.js";
+export { validate } from "@/framework/http/validation.js";
+export { createRoute, z } from "@hono/zod-openapi";
+export * as HttpStatusCodes from "stoker/http-status-codes";
+export { jsonContent } from "stoker/openapi/helpers";
+export { queue, queueJob, shouldQueue } from "@/framework/queue/queue.js";
+export { defineSchedule } from "@/framework/scheduler/scheduler.js";
+export { session } from "@/framework/session/session.js";
+export { cookie } from "@/framework/support/cookie.js";
+export { jwt } from "@/framework/support/jwt.js";
+export { logger } from "@/framework/support/logger.js";
+export { mail } from "@/framework/support/mail.js";
+export { password } from "@/framework/support/password.js";
+export { urls } from "@/framework/support/url.js";
+export { storage } from "@/framework/storage/storage.js";
+export { notify } from "@/framework/notification/index.js";
+export * as lodash from "lodash-es";

package/template/src/framework/http/app.ts

@@ -0,0 +1,61 @@
+import { serveEmojiFavicon } from "stoker/middlewares";
+import { createRoute, z } from "@hono/zod-openapi";
+import { env } from "@/env.js";
+import { configureOpenApi } from "@/framework/http/openapi.js";
+import { corsMiddleware } from "@/framework/http/cors.js";
+import { rateLimiterMiddleware } from "@/framework/http/ratelimiter.js";
+import { hasFrontendBuild, storageStaticMiddleware } from "@/framework/http/static.js";
+import { sessionMiddleware } from "@/framework/session/session.js";
+import { loggerMiddleware, notFound, onError } from "@/framework/http/logger.js";
+import { createRouter } from "@/framework/http/router.js";
+
+/**
+ * Why: Builds the main HTTP app with middleware, health, and error handlers.
+ * When: Kernel creates application server instance.
+ * Where: Framework bootstrap path.
+ * How: Composes router, optional OpenAPI, middleware stack, and fallbacks.
+ */
+export function createHttpApp() {
+  const app = createRouter();
+
+  const healthRoute = createRoute({
+    path: "/health",
+    method: "get",
+    tags: ["System"],
+    responses: {
+      200: {
+        description: "Application health status",
+        content: {
+          "application/json": {
+            schema: z.object({ message: z.string() })
+          }
+        }
+      }
+    }
+  });
+
+  if (env.OPEN_API) {
+    configureOpenApi(app);
+    app.api(healthRoute, (c: any) => c.json({ message: "Application is healthy" }));
+  }
+
+  app.use("*", sessionMiddleware);
+  app.use("*", corsMiddleware);
+  app.use("*", loggerMiddleware);
+  app.use("*", rateLimiterMiddleware);
+  app.use("/storage/*", storageStaticMiddleware);
+  app.use(serveEmojiFavicon("🚀"));
+
+  if (!hasFrontendBuild()) {
+    app.get("/", (c: any) => c.json({ name: env.APP_NAME, ok: true }));
+  }
+
+  if (!env.OPEN_API) {
+    app.get("/health", (c: any) => c.json({ message: "Application is healthy" }));
+  }
+
+  app.notFound(notFound);
+  app.onError(onError);
+
+  return app;
+}

package/template/src/framework/http/cors.ts

@@ -0,0 +1,19 @@
+import { cors } from "hono/cors";
+import { env } from "@/env.js";
+import { parseCsvOrFallback } from "@/framework/support/lifecycle.js";
+
+const corsOrigins = parseCsvOrFallback(env.CORS_ORIGIN, []);
+
+/**
+ * Why: Applies credential-aware CORS policy.
+ * When: Global HTTP middleware processing.
+ * Where: App middleware stack.
+ * How: Reflects origin for wildcard mode or validates against allowlist.
+ */
+export const corsMiddleware = cors({
+  origin: (origin) => {
+    if (env.CORS_ORIGIN === "*") return origin;
+    return corsOrigins.includes(origin) ? origin : undefined;
+  },
+  credentials: true
+});

package/template/src/framework/http/logger.ts

@@ -0,0 +1,85 @@
+import type { Context, Next } from "hono";
+import { logger } from "@/framework/support/logger.js";
+
+function ip(c: Context) {
+  return (
+    c.req.header("cf-connecting-ip") ||
+    c.req.header("x-forwarded-for") ||
+    c.req.header("x-real-ip") ||
+    null
+  );
+}
+
+function shouldSkipHttpLog(pathname: string) {
+  return pathname.startsWith("/bullmq");
+}
+
+/**
+ * Why: Logs each HTTP request with latency and request metadata.
+ * When: Applied globally to app routes.
+ * Where: HTTP middleware stack.
+ * How: Captures start time, assigns request id, logs after downstream response.
+ */
+export async function loggerMiddleware(c: Context, next: Next) {
+  const start = Date.now();
+  const requestId = crypto.randomUUID();
+
+  c.set("requestId", requestId);
+  await next();
+
+  if (shouldSkipHttpLog(c.req.path)) {
+    return;
+  }
+
+  logger.info("HTTP Request", {
+    requestId,
+    method: c.req.method,
+    path: c.req.path,
+    url: c.req.url,
+    status: c.res.status,
+    duration_ms: Date.now() - start,
+    ip: ip(c),
+    userAgent: c.req.header("user-agent") || null
+  });
+}
+
+/**
+ * Why: Standard 404 handler with structured log context.
+ * When: No route matches request path.
+ * Where: App notFound handler registration.
+ * How: Emits warning log and returns JSON 404 payload.
+ */
+export function notFound(c: Context) {
+  logger.warn("404 Not Found", {
+    requestId: c.get("requestId") || null,
+    method: c.req.method,
+    path: c.req.path,
+    url: c.req.url,
+    ip: ip(c),
+    userAgent: c.req.header("user-agent") || null
+  });
+
+  return c.json({ message: "Not Found" }, 404);
+}
+
+/**
+ * Why: Centralized unhandled error responder and logger.
+ * When: Route/middleware throws uncaught error.
+ * Where: App onError handler registration.
+ * How: Logs stack + request context and returns status/message JSON.
+ */
+export function onError(error: any, c: Context) {
+  logger.error("Unhandled Application Error", {
+    requestId: c.get("requestId") || null,
+    name: error?.name || "Error",
+    message: error?.message,
+    stack: error?.stack,
+    method: c.req.method,
+    path: c.req.path,
+    url: c.req.url,
+    ip: ip(c),
+    userAgent: c.req.header("user-agent") || null
+  });
+
+  return c.json({ message: error?.message || "Internal Server Error" }, error?.status || 500);
+}

package/template/src/framework/http/openapi.ts

@@ -0,0 +1,34 @@
+import { Scalar } from "@scalar/hono-api-reference";
+import { env } from "@/env.js";
+import type { NexgenRouter } from "@/framework/http/router.js";
+
+/**
+ * Why: Registers OpenAPI document and interactive docs UI.
+ * When: OPEN_API is enabled during app boot.
+ * Where: HTTP app setup.
+ * How: Exposes `/doc` spec and `/api-docs` Scalar viewer.
+ */
+export function configureOpenApi(app: NexgenRouter) {
+  app.doc("/doc", {
+    openapi: "3.0.0",
+    info: {
+      title: `${env.APP_NAME} API`,
+      version: "0.1.0"
+    }
+  });
+
+  app.get(
+    "/api-docs",
+    Scalar({
+      url: "/doc",
+      layout: "classic",
+      theme: "moon",
+      pageTitle: `${env.APP_NAME} API`,
+      defaultHttpClient: {
+        targetKey: "js",
+        clientKey: "fetch"
+      },
+      defaultOpenAllTags: true
+    })
+  );
+}

package/template/src/framework/http/ratelimiter.ts

@@ -0,0 +1,13 @@
+import { rateLimiter } from "hono-rate-limiter";
+
+/**
+ * Why: Protects API from burst abuse and accidental flooding.
+ * When: Applied globally in HTTP middleware chain.
+ * Where: App bootstrap middleware stack.
+ * How: Limits requests per IP window using forwarded IP key.
+ */
+export const rateLimiterMiddleware = rateLimiter({
+  windowMs: 60_000,
+  limit: 60,
+  keyGenerator: (c) => c.req.header("x-forwarded-for") ?? ""
+});

package/template/src/framework/http/router.ts

@@ -0,0 +1,76 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { defaultHook } from "stoker/openapi";
+
+export type NexgenRouter = OpenAPIHono & {
+  group: (...middlewares: any[]) => NexgenRouter;
+  api: (route: any, handlerOrMiddlewares: any, handler?: any) => NexgenRouter;
+};
+
+/**
+ * Why: Creates the framework router with OpenAPI + helper methods.
+ * When: Building root app and module route files.
+ * Where: HTTP app bootstrap and route stubs.
+ * How: Wraps OpenAPIHono and adds group/api convenience APIs.
+ */
+export function createRouter(): NexgenRouter {
+  const router = new OpenAPIHono({ strict: false, defaultHook }) as NexgenRouter;
+  const baseOpenapi = router.openapi.bind(router);
+
+  router.group = function (...middlewares) {
+    for (const middleware of middlewares) {
+      this.use("*", middleware);
+    }
+
+    return this;
+  };
+
+  router.api = function (route: any, handlerOrMiddlewares: any, handler?: any) {
+    if (!Array.isArray(handlerOrMiddlewares)) {
+      baseOpenapi(route, handlerOrMiddlewares);
+      return this;
+    }
+
+    const middlewares = handlerOrMiddlewares;
+    const finalHandler = handler;
+
+    if (typeof finalHandler !== "function") {
+      throw new Error("api(route, middlewares, handler) requires a handler function");
+    }
+
+    const wrappedHandler = async (c: any) => {
+      let index = 0;
+
+      const next = async (): Promise<any> => {
+        if (index < middlewares.length) {
+          const middleware = middlewares[index++];
+          let downstream: any;
+          const result = await middleware(c, async () => {
+            downstream = await next();
+            return downstream;
+          });
+
+          return result === undefined ? downstream : result;
+        }
+
+        return await finalHandler(c);
+      };
+
+      return await next();
+    };
+
+    baseOpenapi(route, wrappedHandler);
+    return this;
+  };
+
+  return router;
+}
+
+/**
+ * Why: Shorthand for creating grouped router middleware chain.
+ * When: Route files need shared middleware composition.
+ * Where: Module route declarations.
+ * How: Creates a router instance and applies all provided middlewares.
+ */
+export function group(...middlewares: any[]) {
+  return createRouter().group(...middlewares);
+}

package/template/src/framework/http/static.ts

@@ -0,0 +1,33 @@
+import { serveStatic } from "@hono/node-server/serve-static";
+import fsSync from "node:fs";
+
+export function hasFrontendBuild() {
+  return fsSync.existsSync("public/index.html");
+}
+
+/**
+ * Why: Serves public storage files under `/storage/*` URL space.
+ * When: Clients request uploaded public assets.
+ * Where: App middleware stack.
+ * How: Maps `/storage` path prefix to local storage public directory.
+ */
+export const storageStaticMiddleware = serveStatic({
+  root: "./src/storage/app/public",
+  rewriteRequestPath: (path) => path.replace(/^\/storage/, "")
+});
+
+/**
+ * Why: Serves built frontend static assets.
+ * When: SPA build exists in `public` directory.
+ * Where: Kernel frontend integration.
+ * How: Uses node static middleware rooted at `./public`.
+ */
+export const frontendStaticMiddleware = serveStatic({ root: "./public" });
+
+/**
+ * Why: Serves SPA entry file for client-side routed paths.
+ * When: Non-API frontend route fallback is needed.
+ * Where: Kernel catch-all frontend route.
+ * How: Always returns `public/index.html`.
+ */
+export const frontendIndexMiddleware = serveStatic({ path: "./public/index.html" });

package/template/src/framework/http/validation.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+/**
+ * Why: Centralizes schema validation with consistent error shape.
+ * When: Non-route code needs explicit Zod validation.
+ * Where: Controllers/helpers/services.
+ * How: Runs safeParse and throws 422 payload on failure.
+ */
+export async function validate<T extends z.ZodTypeAny>(
+  schema: T,
+  data: unknown
+): Promise<z.infer<T>> {
+  const result = schema.safeParse(data);
+
+  if (!result.success) {
+    throw {
+      status: 422,
+      message: "Validation failed",
+      errors: result.error.flatten()
+    };
+  }
+
+  return result.data;
+}

package/template/src/framework/kernel.ts

@@ -0,0 +1,40 @@
+import { env } from "@/env.js";
+import { createHttpApp } from "@/framework/http/app.js";
+import { registerModuleRoutes } from "@/framework/modules/routes.js";
+import { initDatabase } from "@/framework/database/connection.js";
+import { initRedis } from "@/framework/redis/client.js";
+import { bootQueueJobs } from "@/framework/queue/queue.js";
+import { setupBullBoard } from "@/framework/queue/ui.js";
+import { frontendIndexMiddleware, frontendStaticMiddleware, hasFrontendBuild } from "@/framework/http/static.js";
+import { storage } from "@/framework/storage/storage.js";
+
+/**
+ * Why: Assembles app kernel and boots all framework dependencies.
+ * When: HTTP server startup.
+ * Where: Called by server runtime entrypoint.
+ * How: Initializes storage/db/redis/queues/events/routes and optional frontend.
+ */
+export async function createKernel() {
+  await storage.init();
+
+  const app = createHttpApp();
+
+  await initDatabase();
+  await initRedis();
+  await bootQueueJobs();
+  await registerModuleRoutes(app);
+
+  const bullBoard = setupBullBoard();
+  if (typeof bullBoard.route === "function") {
+    bullBoard.route(app);
+  } else {
+    app.route(bullBoard.basePath, bullBoard.route);
+  }
+
+  if (env.FRONTEND && hasFrontendBuild()) {
+    app.use("/*", frontendStaticMiddleware);
+    app.get("/*", frontendIndexMiddleware);
+  }
+
+  return { app, bullBoard };
+}

package/template/src/framework/maker-cli/src/index.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { config } from "dotenv";
+import { registerModuleCommands } from "./levels/level-2/module/index.mjs";
+import { registerDbCommands } from "./levels/level-2/db/index.mjs";
+import { registerRuntimeCommands } from "./levels/level-2/runtime/index.mjs";
+import { makerCommandPrefix, showHelp } from "./levels/level-1/help.mjs";
+
+const args = process.argv.slice(2);
+const [command] = args;
+
+let deployCommands = new Set();
+let registerDeployCommands = () => {};
+
+try {
+  const deploy = await import("./levels/level-2/deploy/index.mjs");
+  deployCommands = deploy.deployCommands;
+  registerDeployCommands = deploy.registerDeployCommands;
+} catch {
+  /* deploy module not available until user runs deploy:create */
+}
+
+if (!deployCommands.has(command || "")) {
+  config({ path: ".env", quiet: true });
+}
+
+try {
+  const program = new Command();
+  const namePrefix = makerCommandPrefix();
+  program
+    .name(namePrefix ? `${namePrefix} maker` : "maker")
+    .allowUnknownOption(true)
+    .allowExcessArguments(true)
+    .helpOption("-h, --help")
+    .addHelpText("beforeAll", "nexgen maker\n");
+
+  registerModuleCommands(program, args);
+  registerDeployCommands(program, args);
+  registerDbCommands(program, args);
+  registerRuntimeCommands(program, args);
+
+  if (!command) {
+    showHelp(program);
+  } else {
+    await program.parseAsync(args, { from: "user" });
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+}

package/template/src/framework/maker-cli/src/levels/level-1/env-db.mjs

@@ -0,0 +1,57 @@
+const DEFAULT_DATABASE_URL = "sqlite:./src/storage/database/nexgen.sqlite";
+
+/** Detect current DB dialect from DATABASE_URL (sqlite/mysql/postgresql). Falls back to sqlite. */
+export function detectDialect() {
+  const url = String(process.env.DATABASE_URL || DEFAULT_DATABASE_URL).toLowerCase();
+  if (url.startsWith("mysql") || url.startsWith("mariadb")) return "mysql";
+  if (url.startsWith("postgres") || url.startsWith("postgresql")) return "postgresql";
+  return "sqlite";
+}
+
+/** Return the raw DATABASE_URL string or the default sqlite fallback. */
+export function databaseUrl() {
+  return String(process.env.DATABASE_URL || DEFAULT_DATABASE_URL);
+}
+
+/** Parse DATABASE_URL into a URL object. Returns null if invalid. */
+export function parsedDatabaseUrl() {
+  try {
+    return new URL(databaseUrl());
+  } catch {
+    return null;
+  }
+}
+
+/** Extract the database name from the pathname of a parsed DATABASE_URL. */
+export function databaseNameFromUrl(url) {
+  const pathname = String(url?.pathname || "").replace(/^\/+/, "");
+  return pathname ? decodeURIComponent(pathname) : "";
+}
+
+/** Check if OPEN_API env is enabled (defaults to true). */
+export function openApiEnabled() {
+  const value = String(process.env.OPEN_API ?? "true").trim().toLowerCase();
+  return value !== "false" && value !== "0" && value !== "no";
+}
+
+/** Check if REDIS env is enabled (defaults to false). */
+export function redisEnabled() {
+  const value = String(process.env.REDIS ?? "false").trim().toLowerCase();
+  return value === "true" || value === "1" || value === "yes";
+}
+
+/** Detect DB dialect for deploy context (uses raw DATABASE_URL or explicit URL). */
+export function detectDeployDatabase(urlOverride) {
+  const url = String(urlOverride || process.env.DATABASE_URL || "").toLowerCase();
+  if (url.startsWith("mysql") || url.startsWith("mariadb")) return "mysql";
+  if (url.startsWith("postgres") || url.startsWith("postgresql")) return "postgres";
+  return "sqlite";
+}
+
+/** Convert a sqlite:// URL to a filesystem path. */
+export function sqlitePathFromUrl(url) {
+  if (url.startsWith("sqlite:///")) return url.replace("sqlite:///", "/");
+  if (url.startsWith("sqlite://")) return url.replace("sqlite://", "");
+  if (url.startsWith("sqlite:")) return url.replace("sqlite:", "");
+  return url;
+}

package/template/src/framework/maker-cli/src/levels/level-1/file-ops.mjs

@@ -0,0 +1,30 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/** Write a file only if it does not already exist. Returns true if created. */
+export async function writeFileIfMissing(filePath, content) {
+  try {
+    await fs.access(filePath);
+    console.log(`Skipped existing: ${path.relative(process.cwd(), filePath)}`);
+    return false;
+  } catch {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content);
+    console.log(`Created: ${path.relative(process.cwd(), filePath)}`);
+    return true;
+  }
+}
+
+/** Write a file, overwriting if it exists. */
+export async function writeFileAlways(filePath, content) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content);
+  console.log(`Updated: ${path.relative(process.cwd(), filePath)}`);
+}
+
+/** Write multiple files under a root directory using writeFileAlways. */
+export async function writeFiles(root, files) {
+  for (const [relativePath, content] of Object.entries(files)) {
+    await writeFileAlways(path.join(root, relativePath), content);
+  }
+}

package/template/src/framework/maker-cli/src/levels/level-1/flags.mjs

@@ -0,0 +1,16 @@
+/** Check if a specific flag name exists in the flags array. */
+export function hasFlag(flags, name) {
+  return flags.includes(name);
+}
+
+/** Extract the value of a --key=value flag from the flags array. Returns fallback if not found. */
+export function getOption(flags = [], name, fallback = "") {
+  const item = flags.find((flag) => flag.startsWith(`${name}=`));
+  return item ? item.slice(name.length + 1) : fallback;
+}
+
+export function stripWorkflowFlags(flags = []) {
+  return flags.filter(
+    (flag) => !["--server-only", "--app-only", "--refresh", "--dry-run"].includes(flag) && !flag.startsWith("--config=")
+  );
+}

package/template/src/framework/maker-cli/src/levels/level-1/help.mjs

@@ -0,0 +1,24 @@
+/**
+ * Why: Detects the package manager used to run the CLI, for help usage text.
+ * When: Building the program name shown in the "Usage:" line.
+ * Where: Maker CLI entry flow.
+ * How: Reads npm config user-agent and maps to the corresponding prefix string.
+ */
+export function makerCommandPrefix() {
+  const ua = String(process.env.npm_config_user_agent || "").toLowerCase();
+  if (ua.startsWith("pnpm/")) return "pnpm";
+  if (ua.startsWith("yarn/")) return "yarn";
+  if (ua.startsWith("bun/")) return "bun";
+  if (ua.startsWith("npm/")) return "npm run";
+  return "";
+}
+
+/**
+ * Why: Shows commander-generated help for the maker CLI program.
+ * When: CLI runs without a valid command.
+ * Where: Maker CLI entry flow and error handlers.
+ * How: Delegates to commander's outputHelp for consistent automatically-synced output.
+ */
+export function showHelp(program) {
+  program.outputHelp();
+}

package/template/src/framework/maker-cli/src/levels/level-1/naming.mjs

@@ -0,0 +1,13 @@
+/** Validate that a name value exists and return it trimmed+lowercased. Throws if empty. */
+export function assertName(value, label) {
+  if (!value) {
+    throw new Error(`${label} is required.`);
+  }
+
+  return value.trim().toLowerCase();
+}
+
+/** Convert a kebab-case or snake_case string to PascalCase. */
+export function pascal(input) {
+  return input.replace(/(^\w|[-_]\w)/g, (part) => part.replace(/[-_]/g, "").toUpperCase());
+}

package/template/src/framework/maker-cli/src/levels/level-1/process.mjs

@@ -0,0 +1,47 @@
+import { spawn } from "node:child_process";
+import fsSync from "node:fs";
+import path from "node:path";
+
+/** Run a Node.js script as a child process using the current Node executable. */
+export async function runNodeScript(script, args = [], options = {}) {
+  await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [script, ...args], { stdio: options.silent ? "ignore" : "inherit" });
+    child.on("exit", (code) => code === 0 ? resolve() : reject(new Error(`${script} ${args.join(" ")} failed with code ${code}`)));
+    child.on("error", reject);
+  });
+}
+
+/** Resolve the path to a script inside a package in node_modules. */
+export function packageScript(packageName, scriptPath) {
+  return path.resolve(process.cwd(), "node_modules", packageName, scriptPath);
+}
+
+/** Find a local .bin executable (handles OS extensions like .cmd on Windows). */
+export function localBin(name) {
+  const extensions = process.platform === "win32" ? [".cmd", ".exe", ".ps1", ""] : [""];
+
+  for (const extension of extensions) {
+    const candidate = path.resolve(process.cwd(), "node_modules", ".bin", `${name}${extension}`);
+    if (fsSync.existsSync(candidate)) return candidate;
+  }
+
+  throw new Error(`Missing local binary: ${name}. Install project dependencies first.`);
+}
+
+/** Run an arbitrary command as a child process. Uses shell mode for Windows scripts. */
+export async function runCommand(commandName, commandArgs = [], options = {}) {
+  await new Promise((resolve, reject) => {
+    const isWindowsScript = process.platform === "win32" && /\.(cmd|ps1)$/i.test(commandName);
+    const child = isWindowsScript
+      ? spawn(
+        [commandName, ...commandArgs].map((part) => (/\s/.test(part) ? `"${part.replace(/"/g, '\\"')}"` : part)).join(" "),
+        { shell: true, stdio: options.silent ? "ignore" : "inherit" }
+      )
+      : spawn(commandName, commandArgs, { shell: false, stdio: options.silent ? "ignore" : "inherit" });
+
+    child.on("exit", (code) =>
+      code === 0 ? resolve() : reject(new Error(`${commandName} ${commandArgs.join(" ")} failed with code ${code}`))
+    );
+    child.on("error", reject);
+  });
+}