@astra-kit/rp 0.0.0-stage → 0.10.0

package/src/create-version/registry.js

@@ -0,0 +1,220 @@
+/**
+ * Coordinates one selected registry through a shared lookup/authentication/publication contract.
+ *
+ * @module create-version/registry
+ */
+
+import {
+  DEFAULT_NPM_REGISTRY_URL, NPM_AUTH_STATUS, NPM_DIST_TAG, NPM_LOOKUP_STATUS, NPM_PACKAGE_NAME_PATTERN, PROJECT_NPM_CONFIG_FILE,
+} from "../constants/create-version.js";
+import {
+  BROWSER_AUTHENTICATION, GITHUB_PACKAGES_HOST, GITHUB_PACKAGES_REGISTRY_URL, GITHUB_REGISTRY_PROVIDER, GITLAB_PROJECT_REGISTRY_PATTERN,
+  GITLAB_REGISTRY_PROVIDER, JSR_NPM_COMPATIBILITY_HOSTNAME, JSR_REGISTRY_PROVIDER, JSR_REGISTRY_URL, JSR_SHELL_SAFE_TOKEN_PATTERN,
+  NPM_OIDC_MINIMUM_NODE_VERSION, NPM_OIDC_MINIMUM_VERSION, NPM_REGISTRY_PROVIDER, OIDC_AUTHENTICATION, REGISTRY_LABELS, TOKEN_AUTHENTICATION,
+} from "../constants/registry.js";
+import { compareReleaseVersions, isStableReleaseVersion } from "../versions.js";
+import { buildNpmAuthConfigLine, checkNpmPublishAccess, failedLookup, findProjectNpmCredentialKey, lookupPublishedVersions, publishToNpm, resolveNpmToken, resolvePublishRegistry, runNpmCaptured } from "./npm.js";
+import { publishToJsr, readJsrManifest } from "./jsr.js";
+import { isPlainHttpUrl, isRegistryProvider, resolvePublicationOptions } from "./registry-config.js";
+import { lookupHttpRegistry } from "./registry-http.js";
+
+/**
+ * @typedef {{ provider: import("./registry-config.js").RegistryProvider, options: import("./registry-config.js").ResolvedPublicationOptions }} RegistrySelection
+ * @typedef {RegistrySelection & { registryUrl: string, packageName: string, label: string, tag: string | null }} SelectedRegistry
+ */
+
+/**
+ * Selects the configured provider without changing legacy npm hooks or disabled tracking.
+ *
+ * @param {import("./config.js").ResolvedCreateVersionConfig} config - Project configuration.
+ * @returns {RegistrySelection} Selected provider and options.
+ */
+export function selectProjectRegistry(config) {
+  const provider = isRegistryProvider(config.publish) ? config.publish : config.registry ?? NPM_REGISTRY_PROVIDER;
+  return { provider, options: config.publication ?? resolvePublicationOptions(undefined, provider) };
+}
+
+/**
+ * Resolves package identity and endpoint once for the operation; known npm endpoints use their provider policy.
+ *
+ * @param {RegistrySelection} selection - Project selection.
+ * @param {Record<string, unknown>} manifest - Node package manifest.
+ * @param {string} repositoryRoot - Root where registry routing and credentials are read.
+ * @param {string} [packageRoot] - Workspace or checkout directory.
+ * @returns {Promise<SelectedRegistry>} Registry descriptor without secret values.
+ * @throws {Error} When the endpoint or package identity is invalid for its provider.
+ */
+export async function resolveRegistry(selection, manifest, repositoryRoot, packageRoot = repositoryRoot) {
+  let { provider } = selection;
+  const { options } = selection;
+  let registryUrl;
+  let packageName = String(manifest.name);
+  if (provider === JSR_REGISTRY_PROVIDER) {
+    registryUrl = options.registryUrl ?? JSR_REGISTRY_URL;
+    packageName = readJsrManifest(packageRoot, options.configFile).packageName;
+  } else {
+    registryUrl = options.registryUrl ?? (provider === GITHUB_REGISTRY_PROVIDER ? GITHUB_PACKAGES_REGISTRY_URL : await resolvePublishRegistry(manifest, repositoryRoot));
+    const url = new URL(registryUrl);
+    if (provider === NPM_REGISTRY_PROVIDER && url.hostname === GITHUB_PACKAGES_HOST) provider = GITHUB_REGISTRY_PROVIDER;
+    else if (provider === NPM_REGISTRY_PROVIDER && GITLAB_PROJECT_REGISTRY_PATTERN.test(url.pathname)) provider = GITLAB_REGISTRY_PROVIDER;
+    if (!NPM_PACKAGE_NAME_PATTERN.test(packageName)) throw new Error(`Nombre de paquete inválido para ${REGISTRY_LABELS[provider]}`);
+    if (provider === GITHUB_REGISTRY_PROVIDER && !packageName.startsWith("@")) throw new Error("GitHub Packages requiere name con scope (@owner/package) en package.json");
+    if (provider === GITLAB_REGISTRY_PROVIDER && !GITLAB_PROJECT_REGISTRY_PATTERN.test(url.pathname)) throw new Error("GitLab requiere el endpoint /api/v4/projects/<id>/packages/npm/ para publicar");
+    if (url.hostname === JSR_NPM_COMPATIBILITY_HOSTNAME) throw new Error(`${JSR_NPM_COMPATIBILITY_HOSTNAME} permite instalar, pero publicar requiere publish: jsr`);
+  }
+  const url = new URL(registryUrl);
+  if (!isPlainHttpUrl(url)) throw new Error("El registry debe ser una URL http(s) sin credenciales, query ni fragmento");
+  if (options.packageName !== null && options.packageName !== packageName) throw new Error("publication.packageName debe coincidir con el name del manifest que se publica");
+  return { provider, options, registryUrl: url.href, packageName, label: REGISTRY_LABELS[provider], tag: options.tag };
+}
+
+/**
+ * Reads the selected registry through the common version contract, preserving injected legacy npm adapters.
+ *
+ * @param {RegistrySelection} selection - Selected provider.
+ * @param {Record<string, unknown>} manifest - Source manifest.
+ * @param {string} repositoryRoot - Repository containing credentials and routing.
+ * @param {string} [packageRoot] - Workspace package root.
+ * @param {typeof lookupPublishedVersions} [lookupNpm] - Legacy npm boundary.
+ * @returns {Promise<import("./npm.js").NpmLookup>} Published-version state.
+ */
+export async function lookupRegistryVersions(selection, manifest, repositoryRoot, packageRoot = repositoryRoot, lookupNpm = lookupPublishedVersions) {
+  let registry;
+  try {
+    registry = await resolveRegistry(selection, manifest, repositoryRoot, packageRoot);
+  } catch (error) {
+    return describeFailedRegistryLookup(error, selection.provider);
+  }
+  return lookupResolvedRegistryVersions(registry, repositoryRoot, lookupNpm, selection.provider);
+}
+
+/**
+ * Reads the published versions of an already resolved registry through the common version contract.
+ *
+ * @param {SelectedRegistry} registry - Resolved registry.
+ * @param {string} repositoryRoot - Repository containing credentials and routing.
+ * @param {typeof lookupPublishedVersions} lookupNpm - Legacy npm boundary.
+ * @param {import("./registry-config.js").RegistryProvider} selectedProvider - Configured provider, named when the lookup fails.
+ * @returns {Promise<import("./npm.js").NpmLookup>} Published-version state.
+ */
+async function lookupResolvedRegistryVersions(registry, repositoryRoot, lookupNpm, selectedProvider) {
+  try {
+    if (registry.provider === JSR_REGISTRY_PROVIDER || registry.provider === GITLAB_REGISTRY_PROVIDER) {
+      const { token } = resolveNpmToken(repositoryRoot, { tokenVariable: registry.options.tokenEnv });
+      return await lookupHttpRegistry(registry, token);
+    }
+    const lookup = await lookupNpm(registry.packageName, repositoryRoot, registry.registryUrl, { tokenVariable: registry.options.tokenEnv, tag: registry.tag ?? NPM_DIST_TAG, pinScope: true });
+    return registry.provider === NPM_REGISTRY_PROVIDER && registry.tag === NPM_DIST_TAG ? lookup : { ...lookup, registryLabel: registry.label, tag: registry.tag };
+  } catch (error) {
+    return describeFailedRegistryLookup(error, selectedProvider);
+  }
+}
+
+/**
+ * Builds the failed lookup of a registry that could not be resolved or read.
+ *
+ * @param {unknown} error - Thrown value.
+ * @param {import("./registry-config.js").RegistryProvider} selectedProvider - Configured provider.
+ * @returns {import("./npm.js").NpmLookup} Failed lookup labeled with the configured provider.
+ */
+function describeFailedRegistryLookup(error, selectedProvider) {
+  return { ...failedLookup(error instanceof Error ? error.message : "No se pudo resolver el registry"), registryLabel: REGISTRY_LABELS[selectedProvider] };
+}
+
+/**
+ * Checks the destination of an npm-protocol OIDC publication: npm trusted publishing only exists on
+ * the public npm registry, so GitHub Packages, GitLab and any other endpoint can never accept it.
+ * Shared by the worker and by CI preparation, which must reject it before the release tag exists.
+ *
+ * @param {SelectedRegistry} registry - Resolved descriptor of a non-JSR provider.
+ * @returns {string | null} Blocking reason, or `null` when the destination is the public npm registry.
+ */
+export function findNpmOidcRegistryProblem(registry) {
+  return registry.provider !== NPM_REGISTRY_PROVIDER || new URL(registry.registryUrl).href !== DEFAULT_NPM_REGISTRY_URL ? "OIDC de npm requiere el registry público de npm" : null;
+}
+
+/**
+ * Checks a configured OIDC runtime without making a token mandatory or claiming provider write access.
+ *
+ * @param {SelectedRegistry} registry - Resolved descriptor.
+ * @returns {Promise<string | null>} Blocking reason, or `null` when the supported environment is available.
+ */
+async function oidcEnvironmentProblem(registry) {
+  const github = Boolean(process.env.ACTIONS_ID_TOKEN_REQUEST_URL && process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN);
+  const gitlab = Boolean(process.env.GITLAB_CI && process.env.NPM_ID_TOKEN);
+  if (registry.provider === JSR_REGISTRY_PROVIDER) return github ? null : "JSR con OIDC requiere GitHub Actions con id-token: write y el paquete vinculado al repositorio";
+  const registryProblem = findNpmOidcRegistryProblem(registry);
+  if (registryProblem !== null) return registryProblem;
+  if (!github && !gitlab) return "npm con OIDC requiere GitHub Actions o GitLab CI con sus credenciales OIDC configuradas";
+  if (!isStableReleaseVersion(process.versions.node) || compareReleaseVersions(process.versions.node, NPM_OIDC_MINIMUM_NODE_VERSION) < 0) return `OIDC requiere Node >= ${NPM_OIDC_MINIMUM_NODE_VERSION}`;
+  const result = await runNpmCaptured(["--version"], process.cwd());
+  return result.status === 0 && isStableReleaseVersion(result.stdout) && compareReleaseVersions(result.stdout, NPM_OIDC_MINIMUM_VERSION) >= 0 ? null : `OIDC requiere npm >= ${NPM_OIDC_MINIMUM_VERSION}`;
+}
+
+/**
+ * Checks only capabilities the selected provider exposes; unsupported permission checks remain unknown.
+ *
+ * @param {RegistrySelection} selection - Project selection.
+ * @param {Record<string, unknown>} manifest - Node package manifest.
+ * @param {string} repositoryRoot - Credential root.
+ * @param {string} [packageRoot] - Package checkout.
+ * @param {typeof checkNpmPublishAccess} [checkNpmAccess] - Legacy npm check boundary.
+ * @returns {Promise<import("./npm.js").NpmAuthCheck>} Safe credential diagnostic.
+ */
+export async function checkRegistryAccess(selection, manifest, repositoryRoot, packageRoot = repositoryRoot, checkNpmAccess = checkNpmPublishAccess) {
+  const check = { status: NPM_AUTH_STATUS.unknown, user: null, source: null, registryUrl: "", packageName: String(manifest.name), owners: [], firstPublication: false, reason: null, tokenVariable: selection.options.tokenEnv, registryLabel: REGISTRY_LABELS[selection.provider] };
+  /** @type {import("./npm.js").NpmAuthCheck} */
+  let diagnostic = check;
+  try {
+    const registry = await resolveRegistry(selection, manifest, repositoryRoot, packageRoot);
+    diagnostic = { ...diagnostic, registryUrl: registry.registryUrl, packageName: registry.packageName, registryLabel: registry.label };
+    const projectCredentialKey = registry.provider === JSR_REGISTRY_PROVIDER ? null : findProjectNpmCredentialKey(repositoryRoot, registry.registryUrl);
+    if (projectCredentialKey) return { ...diagnostic, status: NPM_AUTH_STATUS.projectCredentials, reason: `${PROJECT_NPM_CONFIG_FILE} define ${projectCredentialKey}` };
+    if (registry.options.authentication === OIDC_AUTHENTICATION) {
+      const reason = await oidcEnvironmentProblem(registry);
+      return { ...diagnostic, status: reason ? NPM_AUTH_STATUS.unsupportedAuth : NPM_AUTH_STATUS.unknown, source: "OIDC", reason: reason ?? `${registry.label}: OIDC configurado; permiso de publicación no verificable sin publicar` };
+    }
+    if (registry.options.authentication === BROWSER_AUTHENTICATION) {
+      const ci = process.env.CI === "true";
+      return { ...diagnostic, status: ci ? NPM_AUTH_STATUS.unsupportedAuth : NPM_AUTH_STATUS.unknown, source: "navegador", reason: ci ? "JSR en CI requiere token u OIDC; no puede autorizarse desde el navegador" : "JSR autoriza la publicación desde el navegador; no se verifican permisos de escritura antes" };
+    }
+    const resolution = resolveNpmToken(repositoryRoot, { tokenVariable: registry.options.tokenEnv });
+    diagnostic = { ...diagnostic, source: resolution.source };
+    if (!resolution.token) return { ...diagnostic, status: NPM_AUTH_STATUS.missingToken };
+    if (registry.provider === JSR_REGISTRY_PROVIDER && !JSR_SHELL_SAFE_TOKEN_PATTERN.test(resolution.token)) return { ...diagnostic, status: NPM_AUTH_STATUS.unsupportedAuth, reason: "El token JSR no se puede pasar de forma segura al cliente oficial" };
+    if (registry.provider !== NPM_REGISTRY_PROVIDER) return { ...diagnostic, reason: `${registry.label}: permiso de escritura no verificable; no se ejecutan npm whoami ni npm owner ls` };
+    const npmAuth = await checkNpmAccess(registry.packageName, repositoryRoot, registry.registryUrl, { tokenVariable: registry.options.tokenEnv, pinScope: true });
+    return { ...npmAuth, tokenVariable: registry.options.tokenEnv, registryLabel: registry.label };
+  } catch (error) {
+    return { ...diagnostic, reason: error instanceof Error ? error.message : "No se pudo verificar la autenticación" };
+  }
+}
+
+/**
+ * Publishes with the chosen protocol and reconciles a failed client before declaring an unpublished version.
+ *
+ * @param {RegistrySelection} selection - One configured provider.
+ * @param {Record<string, unknown>} manifest - Release manifest.
+ * @param {string} repositoryRoot - Routing and credential root.
+ * @param {string} packageRoot - Actual release checkout.
+ * @param {string} version - Stable release version.
+ * @param {string | null} [artifactPath] - Verified npm archive; unused by native JSR.
+ * @returns {Promise<{ registry: SelectedRegistry, exitCode: number, missingToken: boolean, confirmed: boolean }>} Publication and reconciliation result.
+ */
+export async function publishRegistryRelease(selection, manifest, repositoryRoot, packageRoot, version, artifactPath = null) {
+  const registry = await resolveRegistry(selection, manifest, repositoryRoot, packageRoot);
+  const token = registry.options.authentication === TOKEN_AUTHENTICATION ? resolveNpmToken(repositoryRoot, { tokenVariable: registry.options.tokenEnv }).token : null;
+  if (registry.options.authentication === TOKEN_AUTHENTICATION && !token) return { registry, exitCode: 1, missingToken: true, confirmed: false };
+  const jsrManifest = registry.provider === JSR_REGISTRY_PROVIDER ? readJsrManifest(packageRoot, registry.options.configFile) : null;
+  if (jsrManifest && jsrManifest.manifest.version !== version) throw new Error(`JSR: ${jsrManifest.filePath} no declara la versión del release ${version}`);
+  const result = jsrManifest
+    ? { exitCode: await publishToJsr(packageRoot, registry, token, jsrManifest), missingToken: false }
+    : await publishToNpm(repositoryRoot, {
+      authConfigLine: token ? buildNpmAuthConfigLine(registry.registryUrl) : "", artifactPath, packageRoot, registryUrl: registry.registryUrl,
+      tokenVariable: registry.options.tokenEnv, authentication: registry.options.authentication === OIDC_AUTHENTICATION ? OIDC_AUTHENTICATION : TOKEN_AUTHENTICATION, access: registry.options.access, tag: registry.options.tag, packageName: registry.packageName,
+    });
+  if (result.exitCode === 0 && registry.provider !== JSR_REGISTRY_PROVIDER) return { registry, ...result, confirmed: true };
+  const lookup = await lookupResolvedRegistryVersions(registry, repositoryRoot, lookupPublishedVersions, selection.provider);
+  const confirmed = lookup.status === NPM_LOOKUP_STATUS.ok && lookup.publishedVersions.includes(version);
+  return { registry, ...result, confirmed };
+}

package/src/create-version/release-execution.js

@@ -0,0 +1,45 @@
+/**
+ * Records and reads, in the release commit itself, where a release was prepared (`local` or `ci`).
+ * The mark lives in a commit trailer so it covers every release without adding tracked files that the
+ * Vercel build gate would interpret.
+ * @module create-version/release-execution
+ */
+
+import { RELEASE_EXECUTION, RELEASE_EXECUTION_TRAILER } from "../constants/ci-release.js";
+import { ReleaseStepError } from "./errors.js";
+
+/**
+ * Builds the trailer paragraph appended to the release commit message.
+ * @param {"local" | "ci"} execution - Location where the release commit is prepared.
+ * @returns {string} Trailer line such as `Astra-Rp-Execution: ci`.
+ */
+export function formatReleaseExecutionTrailer(execution) {
+  return `${RELEASE_EXECUTION_TRAILER}: ${execution}`;
+}
+
+/**
+ * Reads the execution location recorded in the trailer of a release commit.
+ * Commits created before the trailer existed (or by other tools) have none and yield null.
+ * @param {import("./process.js").GitReader} reader - Git reader of the release checkout.
+ * @param {string} version - Version of the release commit, used in diagnostics.
+ * @param {string} [revision] - Commit holding the trailer; defaults to `HEAD`.
+ * @returns {Promise<"local" | "ci" | null>} Recorded location, or null when the commit carries no trailer.
+ * @throws {ReleaseStepError} When the commit cannot be read, or its trailers are unknown or contradictory.
+ */
+export async function readReleaseExecutionTrailer(reader, version, revision = "HEAD") {
+  const trailerOutput = await reader.tryGit(["log", "-1", `--format=%(trailers:key=${RELEASE_EXECUTION_TRAILER},valueonly=true)`, revision]);
+  if (trailerOutput === null) {
+    throw new ReleaseStepError(`No se pudo leer el trailer ${RELEASE_EXECUTION_TRAILER} del commit de release ${version} (${revision}).`, "Revisá el repositorio con git log -1; no se subió ni publicó nada.");
+  }
+  const recordedValues = [...new Set(trailerOutput.split("\n").map((value) => value.trim()).filter(Boolean))];
+  if (recordedValues.length === 0) return null;
+  const knownExecutions = /** @type {readonly string[]} */ (Object.values(RELEASE_EXECUTION));
+  const [recordedExecution] = recordedValues;
+  if (recordedValues.length > 1 || !knownExecutions.includes(recordedExecution)) {
+    throw new ReleaseStepError(
+      `El commit de release ${version} declara un modo de ejecución inválido en ${RELEASE_EXECUTION_TRAILER}: ${recordedValues.join(", ")} (se espera ${knownExecutions.join(" o ")}).`,
+      "Corregilo con un commit de release nuevo; no se subió ni publicó nada."
+    );
+  }
+  return /** @type {"local" | "ci"} */ (recordedExecution);
+}

package/src/create-version/release-tag-config.js

@@ -0,0 +1,76 @@
+/**
+ * Loads the `create-version` configuration stored in a release tag. `--retry-ci` dispatches the
+ * workflow of the tag with `--ref <tag>` and the worker reloads its configuration from that tag, so
+ * the workflow name and the Actions bindings checked before the retry must come from the tag too,
+ * not from a working tree that later commits may have changed without bumping the version.
+ * @module create-version/release-tag-config
+ */
+
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import path from "node:path";
+
+import { CI_RELEASE_TAG_CONFIG_DIRECTORY_PREFIX } from "../constants/ci-release.js";
+import { CREATE_VERSION_CONFIG_FILES, CREATE_VERSION_FLAG } from "../constants/create-version.js";
+import { loadCreateVersionConfig } from "./config.js";
+import { ReleaseStepError } from "./errors.js";
+import { runCaptured } from "./process.js";
+
+/** Name of the temporary Git index used to check out the tag without touching the project's index. */
+const TEMPORARY_INDEX_FILE = "index";
+
+/** Directory, inside the temporary one, that receives the tagged tree. */
+const TAGGED_TREE_DIRECTORY = "tree";
+
+/**
+ * Runs Git in the repository and fails with a retry-specific diagnostic.
+ * @param {string} repositoryRoot - Project root.
+ * @param {string[]} gitArguments - Git arguments.
+ * @param {string} tag - Release tag being retried, for diagnostics.
+ * @param {NodeJS.ProcessEnv} [environment] - Environment of the Git process.
+ * @returns {Promise<string>} Captured standard output.
+ * @throws {ReleaseStepError} When Git exits with a non-zero status.
+ */
+async function runTagGit(repositoryRoot, gitArguments, tag, environment) {
+  const result = await runCaptured("git", gitArguments, { cwd: repositoryRoot, env: environment });
+  if (result.status !== 0) {
+    throw new ReleaseStepError(
+      `No se pudo leer la configuración guardada en ${tag} (git ${gitArguments[0]} terminó con status ${result.status}: ${result.stderr}).`,
+      `Revisá el repositorio Git y volvé a correr --${CREATE_VERSION_FLAG.retryCi} ${tag}; no se envió ninguna ejecución.`
+    );
+  }
+  return result.stdout;
+}
+
+/**
+ * Checks out a release tag into a temporary directory inside the repository's Git directory and
+ * loads the configuration stored there. The checkout uses its own index, so the project's index,
+ * working tree and refs stay untouched, and it is removed before returning. Placing it under the
+ * project lets the tagged configuration import the dependencies installed in the project root.
+ * @param {string} repositoryRoot - Project root.
+ * @param {string} tag - Release tag already verified against origin, such as `v1.2.4`.
+ * @returns {Promise<import("./config.js").ResolvedCreateVersionConfig>} Configuration the worker loads from the tag.
+ * @throws {ReleaseStepError} When the tag cannot be checked out or its configuration is missing or invalid.
+ */
+export async function loadReleaseTagConfig(repositoryRoot, tag) {
+  const gitDirectory = await runTagGit(repositoryRoot, ["rev-parse", "--absolute-git-dir"], tag);
+  const temporaryDirectory = mkdtempSync(path.join(gitDirectory, CI_RELEASE_TAG_CONFIG_DIRECTORY_PREFIX));
+  try {
+    const taggedTree = path.join(temporaryDirectory, TAGGED_TREE_DIRECTORY);
+    mkdirSync(taggedTree);
+    const environment = { ...process.env, GIT_INDEX_FILE: path.join(temporaryDirectory, TEMPORARY_INDEX_FILE) };
+    await runTagGit(repositoryRoot, ["read-tree", `refs/tags/${tag}^{tree}`], tag, environment);
+    // Git on Windows needs `/` separators in the prefix; the trailing `/` makes it a directory.
+    await runTagGit(repositoryRoot, ["checkout-index", "--all", "--force", `--prefix=${taggedTree.replaceAll("\\", "/")}/`], tag, environment);
+    try {
+      return await loadCreateVersionConfig(taggedTree);
+    } catch (error) {
+      throw new ReleaseStepError(
+        `No se pudo cargar ${CREATE_VERSION_CONFIG_FILES.join(" o ")} desde ${tag}: el worker usa la configuración del tag, no la del working tree.`,
+        `Revisá la configuración commiteada en ${tag} y las dependencias que importa; no se envió ninguna ejecución.`,
+        { cause: error }
+      );
+    }
+  } finally {
+    rmSync(temporaryDirectory, { recursive: true, force: true });
+  }
+}