@reliverse/dler 1.7.92 → 1.7.93

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

@@ -0,0 +1,362 @@
+import path, { dirname } from "@reliverse/pathkit";
+import fs, { ensuredir, rmEnsureDir, setHiddenAttribute } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { selectPrompt } 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 { getRseConfigPath } from "../../config/cfg-path.js";
+import { cliConfigJsonc, cliConfigTs, cliHomeRepos } from "../../config/constants.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) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    const proxy = process.env.https_proxy;
+    const options = proxy ? { agent: new HttpsProxyAgent(proxy) } : {};
+    https.get(url, options, (response) => {
+      if (response.statusCode && response.statusCode >= 400) {
+        reject(
+          new Error(
+            `Failed to download tarball: ${response.statusCode} ${response.statusMessage}`
+          )
+        );
+        return;
+      }
+      response.pipe(file);
+      file.on("finish", () => {
+        file.close(() => resolve());
+      });
+    }).on("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 getRseConfigPath(parentDir, isDev, true);
+  } catch (_error) {
+  }
+  const { configPath: projectConfigPath } = await getRseConfigPath(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);
+    }
+    relinka("verbose", `Extracting tarball to ${projectPath}`);
+    await extractTarball(tarballFile, projectPath, repoInfo.subdir);
+    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) {
+    relinka("info", "Installing dependencies...");
+    await installDependencies({
+      cwd: projectPath,
+      silent: false
+    });
+  }
+  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/app/utils/downloading/handleDownload.d.ts

@@ -0,0 +1,17 @@
+import type { RseConfig } from "../../types/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?: RseConfig | undefined;
+    install?: boolean | undefined;
+    isCustom?: boolean | undefined;
+    isTemplateDownload: boolean;
+    cache?: boolean;
+}): Promise<DownloadResult>;

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

@@ -0,0 +1,160 @@
+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/app/utils/exec/exec-env.js

@@ -0,0 +1,34 @@
+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/app/utils/exec/exec-error.d.ts

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

package/bin/app/utils/exec/exec-error.js

@@ -0,0 +1,15 @@
+export class NonZeroExitError extends Error {
+  result;
+  output;
+  get exitCode() {
+    if (this.result.exitCode !== null) {
+      return this.result.exitCode;
+    }
+    return;
+  }
+  constructor(result, output) {
+    super(`Process exited with non-zero status (${result.exitCode})`);
+    this.result = result;
+    this.output = output;
+  }
+}

package/bin/app/utils/exec/exec-mod.d.ts

@@ -0,0 +1,58 @@
+import { type ChildProcess, type SpawnOptions } from "node:child_process";
+import type { Readable } from "node:stream";
+export interface Output {
+    stderr: string;
+    stdout: string;
+    exitCode: number | undefined;
+}
+export interface PipeOptions extends Options {
+}
+export type KillSignal = Parameters<ChildProcess["kill"]>[0];
+export interface OutputApi extends AsyncIterable<string> {
+    pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
+    process: ChildProcess | undefined;
+    kill(signal?: KillSignal): boolean;
+    get pid(): number | undefined;
+    get aborted(): boolean;
+    get killed(): boolean;
+    get exitCode(): number | undefined;
+}
+export type Result = PromiseLike<Output> & OutputApi;
+export interface Options {
+    signal?: AbortSignal;
+    nodeOptions?: SpawnOptions;
+    timeout?: number;
+    persist?: boolean;
+    stdin?: ExecProcess;
+    throwOnError?: boolean;
+}
+export type XExec = (command: string, args?: string[], options?: Partial<Options>) => Result;
+export declare class ExecProcess implements Result {
+    protected _process?: ChildProcess;
+    protected _aborted: boolean;
+    protected _options: Partial<Options>;
+    protected _command: string;
+    protected _args: string[];
+    protected _resolveClose?: () => void;
+    protected _processClosed: Promise<void>;
+    protected _thrownError?: Error;
+    get process(): ChildProcess | undefined;
+    get pid(): number | undefined;
+    get exitCode(): number | undefined;
+    constructor(command: string, args?: string[], options?: Partial<Options>);
+    kill(signal?: KillSignal): boolean;
+    get aborted(): boolean;
+    get killed(): boolean;
+    pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
+    [Symbol.asyncIterator](): AsyncIterator<string>;
+    protected _waitForOutput(): Promise<Output>;
+    then<TResult1 = Output, TResult2 = never>(onfulfilled?: ((value: Output) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    protected _streamOut?: Readable;
+    protected _streamErr?: Readable;
+    spawn(): void;
+    protected _resetState(): void;
+    protected _onError: (err: Error) => void;
+    protected _onClose: () => void;
+}
+export declare const x: XExec;
+export declare const exec: XExec;