@reliverse/dler 1.7.153 → 2.0.1

package/bin/impl/utils/downloading/downloadRepo.js

@@ -1,412 +0,0 @@
-import path, { dirname } from "@reliverse/pathkit";
-import fs, { ensuredir, rmEnsureDir, setHiddenAttribute } from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import {
-  createFileProgressSpinner,
-  createTransferSpinner,
-  selectPrompt,
-  withEnhancedSpinner
-} from "@reliverse/rempts";
-import { exec } from "child_process";
-import https from "https";
-import { HttpsProxyAgent } from "https-proxy-agent";
-import { installDependencies } from "nypm";
-import prettyBytes from "pretty-bytes";
-import { simpleGit } from "simple-git";
-import { extract } from "tar";
-import { promisify } from "util";
-import { cliConfigJsonc, cliConfigTs, cliHomeRepos } from "../../config/constants.js";
-import { getReliverseConfigPath } from "../../config/path.js";
-import { initGitDir } from "../../init/use-template/cp-modules/git-deploy-prompts/git.js";
-const execAsync = promisify(exec);
-async function getFolderSize(directory, skipDirs = []) {
-  let totalSize = 0;
-  const entries = await fs.readdir(directory);
-  for (const entry of entries) {
-    if (skipDirs.includes(entry)) continue;
-    const fullPath = path.join(directory, entry);
-    const stats = await fs.stat(fullPath);
-    if (stats.isFile()) {
-      totalSize += stats.size;
-    } else if (stats.isDirectory()) {
-      totalSize += await getFolderSize(fullPath, skipDirs);
-    }
-  }
-  return totalSize;
-}
-function parseGitURI(input) {
-  const normalizedInput = input.trim().replace(/^https?:\/\/(www\.)?(github|gitlab|bitbucket|sourcehut)\.com\//, "").replace(/^(github|gitlab|bitbucket|sourcehut)\.com\//, "").replace(/^https?:\/\/git\.sr\.ht\/~/, "").replace(/^git\.sr\.ht\/~/, "");
-  const pattern = /^(?:(?<provider>[^:]+):)?(?<repo>[^#]+)(?<refPart>#[^/]+)?(?<subdir>\/.*)?$/;
-  const match = pattern.exec(normalizedInput);
-  if (!match?.groups) {
-    return {
-      provider: void 0,
-      repo: normalizedInput,
-      ref: "main",
-      subdir: ""
-    };
-  }
-  const { provider, repo, refPart, subdir } = match.groups;
-  return {
-    provider: provider?.trim(),
-    repo: repo?.trim() ?? normalizedInput,
-    ref: refPart ? refPart.slice(1).trim() : "main",
-    subdir: subdir?.trim() ?? ""
-  };
-}
-function getRepoUrl(repo, provider) {
-  switch (provider) {
-    case "gitlab":
-      return `https://gitlab.com/${repo}.git`;
-    case "bitbucket":
-      return `https://bitbucket.org/${repo}.git`;
-    case "sourcehut":
-      return `https://git.sr.ht/~${repo}`;
-    default:
-      return `https://github.com/${repo}.git`;
-  }
-}
-function computeRepoInfo(input, defaultProvider, githubToken, subdirectory) {
-  const { provider: parsedProvider, repo, ref, subdir } = parseGitURI(input);
-  const actualProvider = parsedProvider ?? defaultProvider;
-  const name = repo.replace("/", "-");
-  const headers = {};
-  if (githubToken) {
-    headers.Authorization = `Bearer ${githubToken}`;
-  }
-  const gitUrl = getRepoUrl(repo, actualProvider);
-  return {
-    name,
-    version: ref,
-    subdir: subdirectory ?? subdir.replace(/^\/+/, ""),
-    defaultDir: name,
-    headers,
-    gitUrl
-  };
-}
-async function getUniqueProjectPath(basePath, projectName, isDev) {
-  let iteration = 1;
-  let currentPath = basePath;
-  let currentName = projectName;
-  while (await fs.pathExists(currentPath)) {
-    currentName = `${projectName}-${iteration}`;
-    currentPath = isDev ? path.join(dirname(basePath), "tests-runtime", currentName) : path.join(dirname(basePath), currentName);
-    iteration++;
-  }
-  return currentPath;
-}
-async function getCommitHash(repoUrl, ref) {
-  const { stdout } = await execAsync(`git ls-remote ${repoUrl} ${ref}`);
-  const lines = stdout.split("\n").filter(Boolean);
-  if (!lines.length) {
-    throw new Error(`Could not find commit hash for ref ${ref}`);
-  }
-  const firstLine = lines[0];
-  if (!firstLine) {
-    throw new Error("Invalid git response format");
-  }
-  const [hash] = firstLine.split("	");
-  if (!hash) {
-    throw new Error("Failed to extract commit hash from git response");
-  }
-  return hash;
-}
-function downloadTarball(url, dest, showProgress = false) {
-  return new Promise((resolve, reject) => {
-    const file = fs.createWriteStream(dest);
-    const proxy = process.env.https_proxy;
-    const options = proxy ? { agent: new HttpsProxyAgent(proxy) } : {};
-    let transferSpinner = null;
-    https.get(url, options, (response) => {
-      if (response.statusCode && response.statusCode >= 400) {
-        reject(
-          new Error(
-            `Failed to download tarball: ${response.statusCode} ${response.statusMessage}`
-          )
-        );
-        return;
-      }
-      const totalBytes = parseInt(response.headers["content-length"] || "0", 10);
-      let downloadedBytes = 0;
-      if (showProgress && totalBytes > 0) {
-        transferSpinner = createTransferSpinner("Downloading repository", {
-          totalBytes,
-          showRate: true,
-          color: "blue"
-        });
-      }
-      response.on("data", (chunk) => {
-        downloadedBytes += chunk.length;
-        if (transferSpinner) {
-          transferSpinner.updateBytes(downloadedBytes, path.basename(dest));
-        }
-      });
-      response.pipe(file);
-      file.on("finish", () => {
-        file.close(() => {
-          if (transferSpinner) {
-            transferSpinner.complete("Repository downloaded", totalBytes);
-          }
-          resolve();
-        });
-      });
-    }).on("error", (err) => {
-      if (transferSpinner) {
-        transferSpinner.error(err);
-      }
-      fs.unlink(dest).catch((unlinkErr) => console.error("Failed to unlink:", unlinkErr));
-      reject(err);
-    });
-  });
-}
-async function extractTarball(tarball, dest, subdir = "") {
-  const strip = subdir ? subdir.split("/").length : 1;
-  await extract({ file: tarball, C: dest, strip });
-}
-export async function downloadRepo({
-  repoURL,
-  projectName,
-  isDev,
-  cwd,
-  githubToken,
-  install = false,
-  provider = "github",
-  subdirectory,
-  force = false,
-  forceClean = false,
-  preserveGit = true,
-  config,
-  returnTime = false,
-  returnSize = false,
-  returnConcurrency = false,
-  fastCloneSource,
-  isTemplateDownload,
-  cache = false
-}) {
-  relinka("verbose", `Downloading repo ${repoURL}...`);
-  const startTime = Date.now();
-  let tempCloneDir;
-  const maxConcurrentProcesses = 6;
-  let projectPath = isDev ? path.join(cwd, "tests-runtime", projectName) : path.join(cwd, projectName);
-  relinka("verbose", `Preparing to place repo in: ${projectPath}`);
-  if (forceClean) {
-    await fs.remove(projectPath);
-  } else if (!force && await fs.pathExists(projectPath)) {
-    const files = await fs.readdir(projectPath);
-    const hasOnlyRse = files.length === 1 && files[0] === cliConfigJsonc;
-    if (files.length > 0 && !hasOnlyRse) {
-      projectPath = await getUniqueProjectPath(projectPath, projectName, isDev);
-      relinka("verbose", `Directory already exists. Using new path: ${projectPath}`);
-    }
-  }
-  await ensuredir(projectPath);
-  const parentDir = dirname(projectPath);
-  try {
-    await getReliverseConfigPath(parentDir, isDev, true);
-  } catch (_error) {
-  }
-  const { configPath: projectConfigPath } = await getReliverseConfigPath(projectPath, isDev, true);
-  const hasConfig = await fs.pathExists(projectConfigPath);
-  if (hasConfig) {
-    const choice = await selectPrompt({
-      title: `${projectConfigPath} already exists in parent directory. What would you like to do?`,
-      options: [
-        { value: "delete", label: "Delete existing file" },
-        { value: "backup", label: "Create backup" }
-      ]
-    });
-    if (choice === "delete") {
-      await fs.remove(projectConfigPath);
-    } else {
-      let backupPath = path.join(
-        parentDir,
-        projectConfigPath.endsWith(cliConfigJsonc) ? "rseconfig" : "rseconfig"
-      );
-      let iteration = 1;
-      while (await fs.pathExists(backupPath)) {
-        backupPath = path.join(
-          parentDir,
-          `${projectConfigPath.endsWith(cliConfigJsonc) ? "rseconfig" : "rseconfig"}${iteration}.${projectConfigPath.endsWith(cliConfigJsonc) ? "jsonc" : "ts"}`
-        );
-        iteration++;
-      }
-      await fs.move(projectConfigPath, backupPath);
-    }
-    await fs.move(
-      path.join(
-        projectPath,
-        projectConfigPath.endsWith(cliConfigJsonc) ? cliConfigJsonc : cliConfigTs
-      ),
-      projectConfigPath
-    );
-    await rmEnsureDir(projectPath);
-  }
-  const repoInfo = computeRepoInfo(repoURL, provider, githubToken, subdirectory);
-  if (!repoInfo.gitUrl) {
-    throw new Error(`Invalid repository URL or provider: ${repoURL}`);
-  }
-  let finalUrl = repoInfo.gitUrl;
-  if (githubToken) {
-    const authUrl = new URL(repoInfo.gitUrl);
-    authUrl.username = "oauth2";
-    authUrl.password = githubToken;
-    finalUrl = authUrl.toString();
-  }
-  if (cache && !preserveGit) {
-    relinka("verbose", "Using tarball cache method...");
-    const commitHash = await getCommitHash(finalUrl, repoInfo.version);
-    const tarballCacheDir = path.join(cliHomeRepos, "tarball-cache");
-    await ensuredir(tarballCacheDir);
-    const tarballFile = path.join(tarballCacheDir, `${commitHash}.tar.gz`);
-    if (!await fs.pathExists(tarballFile)) {
-      let tarUrl = "";
-      if (repoInfo.gitUrl.includes("gitlab.com")) {
-        tarUrl = `${repoInfo.gitUrl.replace(".git", "")}/repository/archive.tar.gz?ref=${commitHash}`;
-      } else if (repoInfo.gitUrl.includes("bitbucket.org")) {
-        tarUrl = `${repoInfo.gitUrl.replace(".git", "")}/get/${commitHash}.tar.gz`;
-      } else {
-        tarUrl = `${repoInfo.gitUrl.replace(".git", "")}/archive/${commitHash}.tar.gz`;
-      }
-      relinka("verbose", `Downloading tarball from ${tarUrl}`);
-      await downloadTarball(tarUrl, tarballFile, true);
-    }
-    const extractSpinner = createFileProgressSpinner("Extracting repository", {
-      color: "yellow"
-    });
-    const tarballStats = await fs.stat(tarballFile);
-    extractSpinner.updateProgress(tarballStats.size, path.basename(tarballFile));
-    relinka("verbose", `Extracting tarball to ${projectPath}`);
-    await extractTarball(tarballFile, projectPath, repoInfo.subdir);
-    extractSpinner.complete("Repository extracted successfully");
-    const durationSeconds2 = (Date.now() - startTime) / 1e3;
-    const result2 = { source: repoURL, dir: projectPath };
-    if (returnTime) result2.time = durationSeconds2;
-    if (returnSize) {
-      const folderSizeBytes = await getFolderSize(projectPath, [".git"]);
-      const sizeMB = parseFloat((folderSizeBytes / (1024 * 1024)).toFixed(2));
-      result2.size = sizeMB;
-      result2.sizePretty = prettyBytes(folderSizeBytes);
-    }
-    if (returnConcurrency) result2.concurrency = 1;
-    return result2;
-  }
-  if (fastCloneSource) {
-    relinka("verbose", `Using fast clone method from: ${fastCloneSource}`);
-    await fs.copy(fastCloneSource, path.join(projectPath, ".git"));
-    const git = simpleGit({ maxConcurrentProcesses });
-    await git.cwd(projectPath);
-    await git.checkout(["--", "."]);
-  } else {
-    const git = simpleGit({ maxConcurrentProcesses });
-    try {
-      if (repoInfo.subdir) {
-        if (preserveGit) {
-          await git.clone(finalUrl, projectPath, ["--branch", repoInfo.version]);
-          await git.cwd(projectPath);
-          await git.raw(["sparse-checkout", "init", "--cone"]);
-          await git.raw(["sparse-checkout", "set", repoInfo.subdir]);
-          const subdirPath = path.join(projectPath, repoInfo.subdir);
-          if (!await fs.pathExists(subdirPath)) {
-            throw new Error(`Subdirectory '${repoInfo.subdir}' not found in repository ${repoURL}`);
-          }
-          const files = await fs.readdir(subdirPath);
-          for (const file of files) {
-            await fs.move(path.join(subdirPath, file), path.join(projectPath, file), {
-              overwrite: true
-            });
-          }
-          await fs.remove(subdirPath);
-        } else {
-          tempCloneDir = await fs.mkdtemp(path.join(parentDir, "gitclone-"));
-          await git.clone(finalUrl, tempCloneDir, [
-            "--branch",
-            repoInfo.version,
-            "--depth",
-            "1",
-            "--single-branch"
-          ]);
-          const srcSubdir = path.join(tempCloneDir, repoInfo.subdir);
-          if (!await fs.pathExists(srcSubdir)) {
-            throw new Error(`Subdirectory '${repoInfo.subdir}' not found in repository ${repoURL}`);
-          }
-          await fs.copy(srcSubdir, projectPath, {
-            filter: (src) => !src.includes(`${path.sep}.git`)
-          });
-        }
-      } else {
-        const cloneOptions = ["--branch", repoInfo.version];
-        if (!preserveGit) {
-          cloneOptions.push("--depth", "1", "--single-branch");
-        }
-        await git.clone(finalUrl, projectPath, cloneOptions);
-      }
-      if (!repoInfo.subdir) {
-        if (!preserveGit) {
-          await fs.remove(path.join(projectPath, ".git"));
-          if (config) {
-            relinka("verbose", "[D] initGitDir");
-            await initGitDir({
-              cwd,
-              isDev,
-              projectName,
-              projectPath,
-              allowReInit: true,
-              createCommit: true,
-              config,
-              isTemplateDownload
-            });
-          }
-        } else {
-          await setHiddenAttribute(path.join(projectPath, ".git"));
-        }
-      } else {
-        if (preserveGit) {
-          await setHiddenAttribute(path.join(projectPath, ".git"));
-        }
-      }
-    } finally {
-      if (tempCloneDir && await fs.pathExists(tempCloneDir)) {
-        await fs.remove(tempCloneDir);
-      }
-    }
-  }
-  if (hasConfig) {
-    await fs.move(projectConfigPath, projectConfigPath, {
-      overwrite: true
-    });
-  }
-  if (install) {
-    await withEnhancedSpinner(
-      {
-        text: "Installing dependencies",
-        showTiming: true,
-        successText: "Dependencies installed successfully",
-        failText: "Failed to install dependencies",
-        color: "green"
-      },
-      async (spinner) => {
-        spinner.updateText("Analyzing package.json");
-        await new Promise((resolve) => setTimeout(resolve, 200));
-        spinner.updateText("Downloading packages");
-        await installDependencies({
-          cwd: projectPath,
-          silent: true
-          // Use spinner instead of npm logs
-        });
-        return "installation complete";
-      }
-    );
-  }
-  relinka("verbose", "Repository downloaded successfully!");
-  const durationSeconds = (Date.now() - startTime) / 1e3;
-  const result = { source: repoURL, dir: projectPath };
-  if (returnTime) result.time = durationSeconds;
-  if (returnSize) {
-    const folderSizeBytes = await getFolderSize(projectPath, preserveGit ? [] : [".git"]);
-    const sizeMB = parseFloat((folderSizeBytes / (1024 * 1024)).toFixed(2));
-    result.size = sizeMB;
-    result.sizePretty = prettyBytes(folderSizeBytes);
-  }
-  if (returnConcurrency) result.concurrency = maxConcurrentProcesses;
-  return result;
-}

package/bin/impl/utils/downloading/handleDownload.d.ts

@@ -1,17 +0,0 @@
-import type { ReliverseConfig } from "../../schema/mod.js";
-import { type DownloadResult } from "./downloadRepo.js";
-export declare function handleDownload({ cwd, isDev, skipPrompts, projectPath, projectName, selectedRepo, githubToken, config, preserveGit, install, isCustom, isTemplateDownload, cache, }: {
-    cwd: string;
-    isDev: boolean;
-    skipPrompts: boolean;
-    projectPath: string;
-    projectName: string;
-    selectedRepo: string;
-    githubToken?: string | undefined;
-    preserveGit?: boolean | undefined;
-    config?: ReliverseConfig | undefined;
-    install?: boolean | undefined;
-    isCustom?: boolean | undefined;
-    isTemplateDownload: boolean;
-    cache?: boolean;
-}): Promise<DownloadResult>;

package/bin/impl/utils/downloading/handleDownload.js

@@ -1,160 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs, { setHiddenAttribute } from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { confirmPrompt, selectPrompt } from "@reliverse/rempts";
-import { ofetch } from "ofetch";
-import { cliHomeRepos, UNKNOWN_VALUE } from "../../config/constants.js";
-import { downloadRepo } from "./downloadRepo.js";
-import {
-  getRepoInfo,
-  REPO_TEMPLATES,
-  saveRepoToDevice
-} from "../projectRepository.js";
-async function checkRepoVersion(repo) {
-  const [owner, repoName] = repo.id.split("/");
-  if (!owner || !repoName) return null;
-  const url = `https://ungh.cc/repos/${owner}/${repoName}`;
-  try {
-    const data = await ofetch(url);
-    return data.repo?.pushedAt ?? null;
-  } catch (error) {
-    console.error("Fetch error:", error);
-    return null;
-  }
-}
-export async function handleDownload({
-  cwd,
-  isDev,
-  skipPrompts,
-  projectPath,
-  projectName,
-  selectedRepo,
-  githubToken,
-  config,
-  preserveGit = true,
-  install = false,
-  isCustom = false,
-  isTemplateDownload,
-  cache = false
-}) {
-  if (isTemplateDownload) {
-    relinka("verbose", "Handling template downloading...");
-  }
-  let repo;
-  const foundRepo = REPO_TEMPLATES.find((t) => t.id === selectedRepo);
-  if (foundRepo && !isCustom) {
-    repo = foundRepo;
-  } else {
-    const [author, name] = selectedRepo.split("/");
-    if (!author || !name) {
-      throw new Error(`Invalid repo format: ${selectedRepo}. Expected format: owner/repo`);
-    }
-    repo = {
-      id: selectedRepo,
-      // We trust the user input for custom repos
-      author,
-      name,
-      description: "Custom repository",
-      category: UNKNOWN_VALUE
-    };
-  }
-  const localRepoPath = path.join(cliHomeRepos, repo.author, repo.name);
-  let useLocalRepo = false;
-  if (await fs.pathExists(localRepoPath)) {
-    const localInfo = await getRepoInfo(repo.id);
-    const currentPushedAt = await checkRepoVersion(repo);
-    if (skipPrompts) {
-      useLocalRepo = true;
-      relinka("info", "Using local repo copy (auto).");
-    } else if (localInfo && currentPushedAt) {
-      const localDate = new Date(localInfo.github.pushedAt);
-      const currentDate = new Date(currentPushedAt);
-      if (currentDate > localDate) {
-        const choice = await selectPrompt({
-          title: "A newer version of the repo is available",
-          options: [
-            {
-              label: "Download latest version",
-              value: "download",
-              hint: `Last updated ${currentDate.toLocaleDateString()}`
-            },
-            {
-              label: "Use local copy",
-              value: "local",
-              hint: `Downloaded ${localDate.toLocaleDateString()}`
-            }
-          ]
-        });
-        useLocalRepo = choice === "local";
-      } else {
-        useLocalRepo = true;
-        relinka("info", "Using local repo copy (up to date)...");
-      }
-    } else {
-      useLocalRepo = await confirmPrompt({
-        title: "Local copy found. Use it?",
-        content: "If no, I'll download a fresh version.",
-        defaultValue: true
-      });
-    }
-    if (useLocalRepo) {
-      projectPath = isDev ? path.join(cwd, "tests-runtime", projectName) : path.join(cwd, projectName);
-      await fs.copy(localRepoPath, projectPath);
-      await setHiddenAttribute(path.join(projectPath, ".git"));
-    }
-  }
-  let result;
-  const term = isTemplateDownload ? "template" : "repo";
-  if (!projectPath) {
-    try {
-      relinka(
-        "info",
-        `Now I'm downloading the '${selectedRepo}' ${term}...`,
-        "The download speed depends on your internet connection and GitHub limits."
-      );
-      result = await downloadRepo({
-        repoURL: selectedRepo,
-        projectName,
-        isDev,
-        cwd,
-        ...githubToken ? { githubToken } : {},
-        preserveGit,
-        ...config ? { config } : {},
-        install,
-        returnTime: true,
-        returnSize: true,
-        isTemplateDownload,
-        cache
-      });
-      projectPath = result.dir;
-      if (result.time) {
-        const includesGit = preserveGit ? " (size includes the preserved .git folder)." : ".";
-        relinka(
-          "success",
-          `Successfully downloaded ${term} to ${projectPath}`,
-          `It took ${result.time} seconds to download ${result.sizePretty}${includesGit}`
-        );
-      }
-    } catch (error) {
-      relinka("error", `Failed to download ${term}:`, String(error));
-      throw error;
-    }
-  } else {
-    result = {
-      source: selectedRepo,
-      dir: projectPath
-    };
-  }
-  let shouldSaveRepo = !useLocalRepo;
-  if (!skipPrompts && !useLocalRepo) {
-    shouldSaveRepo = await confirmPrompt({
-      title: `Save a copy of the ${term} to your device?`,
-      content: `This is useful if you have limited internet data or plan to reuse the ${term} soon.`,
-      defaultValue: true
-    });
-  }
-  if (shouldSaveRepo) {
-    await saveRepoToDevice(repo, projectPath);
-  }
-  return result;
-}

package/bin/impl/utils/exec/exec-enoent.d.ts

@@ -1,15 +0,0 @@
-import type { ChildProcess } from "node:child_process";
-import type { ExecParseResult } from "./exec-types.js";
-export declare function notFoundError(original: {
-    command: string;
-    args: string[];
-}, syscall: string): Error & {
-    code: string;
-    errno: string;
-    syscall: string;
-    path: string;
-    spawnargs: string[];
-};
-export declare function hookChildProcess(cp: ChildProcess, parsed: ExecParseResult): void;
-export declare function verifyENOENT(status: number | null, parsed: ExecParseResult): Error | null;
-export declare function verifyENOENTSync(status: number | null, parsed: ExecParseResult): Error | null;

package/bin/impl/utils/exec/exec-enoent.js

@@ -1,38 +0,0 @@
-const isWin = process.platform === "win32";
-export function notFoundError(original, syscall) {
-  return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
-    code: "ENOENT",
-    errno: "ENOENT",
-    syscall: `${syscall} ${original.command}`,
-    path: original.command,
-    spawnargs: original.args
-  });
-}
-export function hookChildProcess(cp, parsed) {
-  if (!isWin) return;
-  const originalEmit = cp.emit;
-  cp.emit = (name, ...args) => {
-    if (name === "exit") {
-      const code = args[0];
-      const signal = args[1];
-      const err = verifyENOENT(code ?? 0, parsed);
-      if (err) {
-        return originalEmit.apply(cp, ["error", err]);
-      }
-      return originalEmit.apply(cp, ["exit", code, signal]);
-    }
-    return originalEmit.apply(cp, [name, ...args]);
-  };
-}
-export function verifyENOENT(status, parsed) {
-  if (isWin && status === 1 && !parsed.file) {
-    return notFoundError(parsed.original, "spawn");
-  }
-  return null;
-}
-export function verifyENOENTSync(status, parsed) {
-  if (isWin && status === 1 && !parsed.file) {
-    return notFoundError(parsed.original, "spawnSync");
-  }
-  return null;
-}

package/bin/impl/utils/exec/exec-env.d.ts

@@ -1,6 +0,0 @@
-export type EnvLike = typeof process.env;
-export interface EnvPathInfo {
-    key: string;
-    value: string;
-}
-export declare function computeEnv(cwd: string, env?: EnvLike): EnvLike;

package/bin/impl/utils/exec/exec-env.js

@@ -1,34 +0,0 @@
-import { dirname, delimiter as pathDelimiter, resolve as resolvePath } from "node:path";
-const isPathLikePattern = /^path$/i;
-const defaultEnvPathInfo = { key: "PATH", value: "" };
-function getPathFromEnv(env) {
-  for (const key in env) {
-    if (!Object.hasOwn(env, key) || !isPathLikePattern.test(key)) {
-      continue;
-    }
-    const value = env[key];
-    if (!value) return defaultEnvPathInfo;
-    return { key, value };
-  }
-  return defaultEnvPathInfo;
-}
-function addNodeBinToPath(cwd, path) {
-  const parts = path.value.split(pathDelimiter);
-  let currentPath = cwd;
-  let lastPath;
-  do {
-    parts.push(resolvePath(currentPath, "node_modules", ".bin"));
-    lastPath = currentPath;
-    currentPath = dirname(currentPath);
-  } while (currentPath !== lastPath);
-  return { key: path.key, value: parts.join(pathDelimiter) };
-}
-export function computeEnv(cwd, env) {
-  const envWithDefault = {
-    ...process.env,
-    ...env
-  };
-  const envPathInfo = addNodeBinToPath(cwd, getPathFromEnv(envWithDefault));
-  envWithDefault[envPathInfo.key] = envPathInfo.value;
-  return envWithDefault;
-}

package/bin/impl/utils/exec/exec-error.d.ts

@@ -1,7 +0,0 @@
-import type { Output, Result } from "./exec-mod";
-export declare class NonZeroExitError extends Error {
-    readonly result: Result;
-    readonly output?: Output;
-    get exitCode(): number | undefined;
-    constructor(result: Result, output?: Output);
-}