@reliverse/dler 1.7.60 → 1.7.62

package/bin/libs/sdk/sdk-impl/utils/exec/exec-mod.js

@@ -0,0 +1,231 @@
+import { spawn } from "node:child_process";
+import { normalize as normalizePath } from "node:path";
+import { cwd as getCwd } from "node:process";
+import readline from "node:readline";
+import { computeEnv } from "./exec-env.js";
+import { NonZeroExitError } from "./exec-error.js";
+import { combineStreams } from "./exec-stream.js";
+import { _parse } from "./exec-types.js";
+const defaultOptions = {
+  timeout: void 0,
+  persist: false
+};
+const defaultNodeOptions = {
+  windowsHide: true
+};
+function normaliseCommandAndArgs(command, args) {
+  const normalisedPath = normalizePath(command);
+  const normalisedArgs = args ?? [];
+  return {
+    command: normalisedPath,
+    args: normalisedArgs
+  };
+}
+function combineSignals(signals) {
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort();
+      return signal;
+    }
+    const onAbort = () => {
+      controller.abort(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, {
+      signal: controller.signal
+    });
+  }
+  return controller.signal;
+}
+export class ExecProcess {
+  _process;
+  _aborted = false;
+  _options;
+  _command;
+  _args;
+  _resolveClose;
+  _processClosed;
+  _thrownError;
+  get process() {
+    return this._process;
+  }
+  get pid() {
+    return this._process?.pid;
+  }
+  get exitCode() {
+    if (this._process && this._process.exitCode !== null) {
+      return this._process.exitCode;
+    }
+    return void 0;
+  }
+  constructor(command, args, options) {
+    this._options = {
+      ...defaultOptions,
+      ...options
+    };
+    this._command = command;
+    this._args = args ?? [];
+    this._processClosed = new Promise((resolve) => {
+      this._resolveClose = resolve;
+    });
+  }
+  kill(signal) {
+    return this._process?.kill(signal) === true;
+  }
+  get aborted() {
+    return this._aborted;
+  }
+  get killed() {
+    return this._process?.killed === true;
+  }
+  pipe(command, args, options) {
+    return exec(command, args, {
+      ...options,
+      stdin: this
+    });
+  }
+  async *[Symbol.asyncIterator]() {
+    const proc = this._process;
+    if (!proc) {
+      return;
+    }
+    const streams = [];
+    if (this._streamErr) {
+      streams.push(this._streamErr);
+    }
+    if (this._streamOut) {
+      streams.push(this._streamOut);
+    }
+    const streamCombined = combineStreams(streams);
+    const rl = readline.createInterface({
+      input: streamCombined
+    });
+    for await (const chunk of rl) {
+      yield chunk.toString();
+    }
+    await this._processClosed;
+    proc.removeAllListeners();
+    if (this._thrownError) {
+      throw this._thrownError;
+    }
+    if (this._options?.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) {
+      throw new NonZeroExitError(this);
+    }
+  }
+  async _waitForOutput() {
+    const proc = this._process;
+    if (!proc) {
+      throw new Error("No process was started");
+    }
+    let stderr = "";
+    let stdout = "";
+    if (this._streamOut) {
+      for await (const chunk of this._streamOut) {
+        stdout += chunk.toString();
+      }
+    }
+    if (this._streamErr) {
+      for await (const chunk of this._streamErr) {
+        stderr += chunk.toString();
+      }
+    }
+    await this._processClosed;
+    if (this._options?.stdin) {
+      await this._options.stdin;
+    }
+    proc.removeAllListeners();
+    if (this._thrownError) {
+      throw this._thrownError;
+    }
+    const result = {
+      stderr,
+      stdout,
+      exitCode: this.exitCode
+    };
+    if (this._options.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) {
+      throw new NonZeroExitError(this, result);
+    }
+    return result;
+  }
+  // biome-ignore lint/suspicious/noThenProperty: <>
+  then(onfulfilled, onrejected) {
+    return this._waitForOutput().then(onfulfilled, onrejected);
+  }
+  _streamOut;
+  _streamErr;
+  spawn() {
+    const cwd = getCwd();
+    const options = this._options;
+    const nodeOptions = {
+      ...defaultNodeOptions,
+      ...options.nodeOptions
+    };
+    const signals = [];
+    this._resetState();
+    if (options.timeout !== void 0) {
+      signals.push(AbortSignal.timeout(options.timeout));
+    }
+    if (options.signal !== void 0) {
+      signals.push(options.signal);
+    }
+    if (options.persist === true) {
+      nodeOptions.detached = true;
+    }
+    if (signals.length > 0) {
+      nodeOptions.signal = combineSignals(signals);
+    }
+    nodeOptions.env = computeEnv(cwd, nodeOptions.env);
+    const { command: normalisedCommand, args: normalisedArgs } = normaliseCommandAndArgs(
+      this._command,
+      this._args
+    );
+    const crossResult = _parse(normalisedCommand, normalisedArgs, nodeOptions);
+    let handle;
+    if (process.versions.bun) {
+      const bunSpawn = Bun.spawn;
+      handle = bunSpawn(crossResult.command, crossResult.args, crossResult.options);
+    } else {
+      handle = spawn(crossResult.command, crossResult.args, crossResult.options);
+    }
+    if (handle.stderr) {
+      this._streamErr = handle.stderr;
+    }
+    if (handle.stdout) {
+      this._streamOut = handle.stdout;
+    }
+    this._process = handle;
+    handle.once("error", this._onError);
+    handle.once("close", this._onClose);
+    if (options.stdin !== void 0 && handle.stdin && options.stdin.process) {
+      const { stdout } = options.stdin.process;
+      if (stdout) {
+        stdout.pipe(handle.stdin);
+      }
+    }
+  }
+  _resetState() {
+    this._aborted = false;
+    this._processClosed = new Promise((resolve) => {
+      this._resolveClose = resolve;
+    });
+    this._thrownError = void 0;
+  }
+  _onError = (err) => {
+    if (err.name === "AbortError" && (!(err.cause instanceof Error) || err.cause.name !== "TimeoutError")) {
+      this._aborted = true;
+      return;
+    }
+    this._thrownError = err;
+  };
+  _onClose = () => {
+    if (this._resolveClose) {
+      this._resolveClose();
+    }
+  };
+}
+export const x = (command, args, userOptions) => {
+  const proc = new ExecProcess(command, args, userOptions);
+  proc.spawn();
+  return proc;
+};
+export const exec = x;

package/bin/libs/sdk/sdk-impl/utils/exec/exec-parse.d.ts

@@ -0,0 +1,2 @@
+import type { ExecParseResult } from "./exec-types.js";
+export declare function parse(command: string, args?: string[] | any, options?: any): Promise<ExecParseResult>;

package/bin/libs/sdk/sdk-impl/utils/exec/exec-parse.js

@@ -0,0 +1,56 @@
+import path from "node:path";
+import { escapeCommand, escapeArgument } from "./exec-escape.js";
+import { resolveCommand } from "./exec-resolve.js";
+import { readShebang } from "./exec-shebang.js";
+const isWin = process.platform === "win32";
+const isExecutableRegExp = /\.(?:com|exe)$/i;
+const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+async function detectShebang(parsed) {
+  parsed.file = await resolveCommand(parsed);
+  if (parsed.file) {
+    const shebang = readShebang(parsed.file);
+    if (shebang) {
+      parsed.args.unshift(parsed.file);
+      parsed.command = shebang;
+      return await resolveCommand(parsed);
+    }
+  }
+  return parsed.file;
+}
+async function parseNonShell(parsed) {
+  if (!isWin) return parsed;
+  const commandFile = await detectShebang(parsed);
+  const needsShell = !isExecutableRegExp.test(commandFile ?? "");
+  if (parsed.options.forceShell || needsShell) {
+    const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile ?? "");
+    let cmd = path.normalize(parsed.command);
+    cmd = escapeCommand(cmd);
+    const args = parsed.args.map((arg) => escapeArgument(arg, needsDoubleEscapeMetaChars));
+    const shellCommand = [cmd].concat(args).join(" ");
+    parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+    parsed.command = process.env.comspec || "cmd.exe";
+    parsed.options.windowsVerbatimArguments = true;
+  }
+  return parsed;
+}
+export async function parse(command, args, options) {
+  let actualArgs = args;
+  let actualOptions = options;
+  if (actualArgs && !Array.isArray(actualArgs)) {
+    actualOptions = actualArgs;
+    actualArgs = null;
+  }
+  actualArgs = actualArgs ? actualArgs.slice(0) : [];
+  actualOptions = Object.assign({}, actualOptions);
+  const parsed = {
+    command,
+    args: actualArgs,
+    options: actualOptions,
+    file: void 0,
+    original: {
+      command,
+      args: actualArgs
+    }
+  };
+  return actualOptions.shell ? parsed : await parseNonShell(parsed);
+}

package/bin/libs/sdk/sdk-impl/utils/exec/exec-resolve.d.ts

@@ -0,0 +1,2 @@
+import type { ExecParseResult } from "./exec-types.js";
+export declare function resolveCommand(parsed: ExecParseResult): Promise<string | undefined>;

package/bin/libs/sdk/sdk-impl/utils/exec/exec-resolve.js

@@ -0,0 +1,39 @@
+import { lookpath } from "lookpath";
+import path from "node:path";
+import getPathKey from "path-key";
+async function resolveCommandAttempt(parsed, withoutPathExt) {
+  const env = parsed.options.env || process.env;
+  const cwd = process.cwd();
+  const hasCustomCwd = parsed.options.cwd != null;
+  const shouldSwitchCwd = hasCustomCwd && typeof process.chdir === "function" && !process.chdir.disabled;
+  if (shouldSwitchCwd) {
+    try {
+      process.chdir(String(parsed.options.cwd ?? cwd));
+    } catch {
+    }
+  }
+  let resolved;
+  try {
+    const pathEnv = env[getPathKey({ env })];
+    const lookpathOptions = {
+      path: pathEnv?.split(path.delimiter),
+      include: withoutPathExt ? [] : void 0
+    };
+    resolved = await lookpath(parsed.command, lookpathOptions);
+  } catch {
+  } finally {
+    if (shouldSwitchCwd) {
+      process.chdir(cwd);
+    }
+  }
+  if (resolved) {
+    resolved = path.resolve(
+      hasCustomCwd ? String(parsed.options.cwd ?? cwd) : cwd,
+      typeof resolved === "string" ? resolved : String(resolved)
+    );
+  }
+  return resolved;
+}
+export async function resolveCommand(parsed) {
+  return await resolveCommandAttempt(parsed) || await resolveCommandAttempt(parsed, true);
+}

package/bin/libs/sdk/sdk-impl/utils/exec/exec-shebang.d.ts

@@ -0,0 +1 @@
+export declare function readShebang(command: string): string | null;

package/bin/libs/sdk/sdk-impl/utils/exec/exec-shebang.js

@@ -0,0 +1,14 @@
+import fs from "node:fs";
+import shebangCommand from "shebang-command";
+export function readShebang(command) {
+  const size = 150;
+  const buffer = Buffer.alloc(size);
+  let fd;
+  try {
+    fd = fs.openSync(command, "r");
+    fs.readSync(fd, buffer, 0, size, 0);
+    fs.closeSync(fd);
+  } catch {
+  }
+  return shebangCommand(buffer.toString());
+}

package/bin/libs/sdk/sdk-impl/utils/exec/exec-spawn.d.ts

@@ -0,0 +1,3 @@
+import { type ChildProcess, type SpawnOptions, type SpawnSyncReturns } from "node:child_process";
+export declare function spawn(command: string, args?: string[], options?: SpawnOptions): Promise<ChildProcess>;
+export declare function spawnSync(command: string, args?: string[], options?: SpawnOptions): Promise<SpawnSyncReturns<string | Buffer<ArrayBufferLike>>>;

package/bin/libs/sdk/sdk-impl/utils/exec/exec-spawn.js

@@ -0,0 +1,18 @@
+import {
+  spawn as nodeSpawn,
+  spawnSync as nodeSpawnSync
+} from "node:child_process";
+import { hookChildProcess, verifyENOENTSync } from "./exec-enoent.js";
+import { parse } from "./exec-parse.js";
+export async function spawn(command, args, options) {
+  const parsed = await parse(command, args, options);
+  const spawned = nodeSpawn(parsed.command, parsed.args, parsed.options);
+  hookChildProcess(spawned, parsed);
+  return spawned;
+}
+export async function spawnSync(command, args, options) {
+  const parsed = await parse(command, args, options);
+  const result = nodeSpawnSync(parsed.command, parsed.args, parsed.options);
+  result.error = result.error || verifyENOENTSync(result.status, parsed);
+  return result;
+}

package/bin/libs/sdk/sdk-impl/utils/exec/exec-stream.d.ts

@@ -0,0 +1,4 @@
+import type { EventEmitter } from "node:events";
+import { type Readable } from "node:stream";
+export declare const waitForEvent: (emitter: EventEmitter, name: string) => Promise<void>;
+export declare const combineStreams: (streams: Readable[]) => Readable;

package/bin/libs/sdk/sdk-impl/utils/exec/exec-stream.js

@@ -0,0 +1,20 @@
+import { PassThrough } from "node:stream";
+export const waitForEvent = (emitter, name) => {
+  return new Promise((resolve) => {
+    emitter.on(name, resolve);
+  });
+};
+export const combineStreams = (streams) => {
+  let streamCount = streams.length;
+  const combined = new PassThrough();
+  const maybeEmitEnd = () => {
+    if (--streamCount === 0) {
+      combined.emit("end");
+    }
+  };
+  for (const stream of streams) {
+    stream.pipe(combined, { end: false });
+    stream.on("end", maybeEmitEnd);
+  }
+  return combined;
+};

package/bin/libs/sdk/sdk-impl/utils/exec/exec-types.d.ts

@@ -0,0 +1,13 @@
+import type { ChildProcess, SpawnOptions } from "node:child_process";
+export type { ChildProcess, SpawnOptions };
+export interface ExecParseResult {
+    command: string;
+    args: string[];
+    options: SpawnOptions;
+    file?: string;
+    original: {
+        command: string;
+        args: string[];
+    };
+}
+export declare function _parse(file: string, args: string[], options?: SpawnOptions): ExecParseResult;

package/bin/libs/sdk/sdk-impl/utils/exec/exec-types.js

@@ -0,0 +1,9 @@
+export function _parse(file, args, options) {
+  return {
+    command: file,
+    args,
+    options: options ?? {},
+    file,
+    original: { command: file, args }
+  };
+}

package/bin/libs/sdk/sdk-impl/utils/fs-rename.d.ts

@@ -0,0 +1,2 @@
+export declare function safeRename(source: string, destination: string): Promise<void>;
+export declare function prepareCLIFiles(revert?: boolean, recursive?: boolean, useDtsTxtForPrepareMyCLI?: boolean): Promise<void>;

package/bin/libs/sdk/sdk-impl/utils/fs-rename.js

@@ -0,0 +1,108 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+async function fileExists(path2) {
+  try {
+    await fs.access(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export async function safeRename(source, destination) {
+  if (await fileExists(destination)) {
+    throw new Error(`Destination file already exists: ${destination}`);
+  }
+  await fs.rename(source, destination);
+}
+function isCommonJSFile(content) {
+  return content.includes("module.exports") || content.includes("require(");
+}
+async function getAllFilesAsync(dir, baseDir = dir, recursive = true) {
+  let fileList = [];
+  const entries = await fs.readdir(dir, {
+    encoding: "utf8",
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (recursive) {
+        const subFiles = await getAllFilesAsync(fullPath, baseDir, recursive);
+        fileList = fileList.concat(subFiles);
+      }
+    } else if (entry.isFile()) {
+      fileList.push(fullPath.slice(baseDir.length + 1));
+    }
+  }
+  return fileList;
+}
+export async function prepareCLIFiles(revert = false, recursive = true, useDtsTxtForPrepareMyCLI = false) {
+  relinka("log", "Starting CLI file preparation...");
+  const configPath = ".config/dler.ts";
+  let srcDir = "src";
+  if (fs.existsSync(configPath)) {
+    const configContent = fs.readFileSync(configPath, "utf8");
+    const configMatch = configContent.match(/coreEntrySrcDir:\s*["']([^"']+)["']/);
+    srcDir = configMatch?.[1] ?? srcDir;
+  }
+  if (!fs.existsSync(srcDir)) {
+    throw new Error(`Source directory not found: ${srcDir}`);
+  }
+  const files = await getAllFilesAsync(srcDir, srcDir, recursive);
+  relinka("log", `Found ${files.length} files to process.`);
+  let renamedCount = 0;
+  for (const file of files) {
+    const fullPath = path.join(srcDir, file);
+    if (!await fileExists(fullPath)) continue;
+    const ext = path.extname(file);
+    const fileName = path.basename(file);
+    const baseName = path.basename(file, ext);
+    const dir = path.dirname(fullPath);
+    if (revert) {
+      if (file.endsWith(".json.json")) {
+        const originalName = path.join(dir, fileName.replace(".json.json", ".json"));
+        relinka("log", `Reverting ${fullPath} to ${originalName}`);
+        await safeRename(fullPath, originalName);
+        renamedCount++;
+      } else if (file.endsWith(".d.ts.txt") && useDtsTxtForPrepareMyCLI) {
+        const originalName = path.join(dir, fileName.replace(".d.ts.txt", ".d.ts"));
+        relinka("log", `Reverting ${fullPath} to ${originalName}`);
+        await safeRename(fullPath, originalName);
+        renamedCount++;
+      } else if (file.endsWith(".cjs")) {
+        const originalName = path.join(dir, `${baseName}.js`);
+        relinka("log", `Reverting ${fullPath} to ${originalName}`);
+        await safeRename(fullPath, originalName);
+        renamedCount++;
+      }
+    } else {
+      if (fileName === "tsconfig.json" && !fileName.endsWith(".json.json")) {
+        const newName = path.join(dir, "tsconfig.json.json");
+        relinka("log", `Renaming ${fullPath} to ${newName}`);
+        await safeRename(fullPath, newName);
+        renamedCount++;
+      } else if (fileName === "package.json" && !fileName.endsWith(".json.json")) {
+        const newName = path.join(dir, "package.json.json");
+        relinka("log", `Renaming ${fullPath} to ${newName}`);
+        await safeRename(fullPath, newName);
+        renamedCount++;
+      } else if (fileName.endsWith(".d.ts") && !fileName.endsWith(".d.ts.txt") && useDtsTxtForPrepareMyCLI) {
+        const baseWithoutD = baseName.slice(0, -2);
+        const newName = path.join(dir, `${baseWithoutD}.d.ts.txt`);
+        relinka("log", `Renaming ${fullPath} to ${newName}`);
+        await safeRename(fullPath, newName);
+        renamedCount++;
+      } else if (fileName.endsWith(".js") && !fileName.endsWith(".cjs")) {
+        const content = fs.readFileSync(fullPath, "utf8");
+        if (isCommonJSFile(content)) {
+          const newName = path.join(dir, `${baseName}.cjs`);
+          relinka("log", `Renaming ${fullPath} to ${newName}`);
+          await safeRename(fullPath, newName);
+          renamedCount++;
+        }
+      }
+    }
+  }
+  relinka("log", `CLI file preparation completed. Renamed ${renamedCount} files.`);
+}

package/bin/libs/sdk/sdk-impl/utils/pm/pm-api.d.ts

@@ -0,0 +1,85 @@
+import type { OperationOptions } from "./pm-types";
+/**
+ * Installs project dependencies.
+ *
+ * @param options - Options to pass to the API call.
+ * @param options.cwd - The directory to run the command in.
+ * @param options.silent - Whether to run the command in silent mode.
+ * @param options.packageManager - The package manager info to use (auto-detected).
+ * @param options.frozenLockFile - Whether to install dependencies with frozen lock file.
+ */
+export declare function installDependencies(options?: Pick<OperationOptions, "cwd" | "silent" | "packageManager"> & {
+    frozenLockFile?: boolean;
+}): Promise<void>;
+/**
+ * Adds dependency to the project.
+ *
+ * @param name - Name of the dependency to add.
+ * @param options - Options to pass to the API call.
+ * @param options.cwd - The directory to run the command in.
+ * @param options.silent - Whether to run the command in silent mode.
+ * @param options.packageManager - The package manager info to use (auto-detected).
+ * @param options.dev - Whether to add the dependency as dev dependency.
+ * @param options.workspace - The name of the workspace to use.
+ * @param options.global - Whether to run the command in global mode.
+ */
+export declare function addDependency(name: string | string[], options?: OperationOptions): Promise<void>;
+/**
+ * Adds dev dependency to the project.
+ *
+ * @param name - Name of the dev dependency to add.
+ * @param options - Options to pass to the API call.
+ * @param options.cwd - The directory to run the command in.
+ * @param options.silent - Whether to run the command in silent mode.
+ * @param options.packageManager - The package manager info to use (auto-detected).
+ * @param options.workspace - The name of the workspace to use.
+ * @param options.global - Whether to run the command in global mode.
+ *
+ */
+export declare function addDevDependency(name: string | string[], options?: Omit<OperationOptions, "dev">): Promise<void>;
+/**
+ * Removes dependency from the project.
+ *
+ * @param name - Name of the dependency to remove.
+ * @param options - Options to pass to the API call.
+ * @param options.cwd - The directory to run the command in.
+ * @param options.silent - Whether to run the command in silent mode.
+ * @param options.packageManager - The package manager info to use (auto-detected).
+ * @param options.dev - Whether to remove dev dependency.
+ * @param options.workspace - The name of the workspace to use.
+ * @param options.global - Whether to run the command in global mode.
+ */
+export declare function removeDependency(name: string | string[], options?: OperationOptions): Promise<void>;
+/**
+ * Ensures dependency is installed.
+ *
+ * @param name - Name of the dependency.
+ * @param options - Options to pass to the API call.
+ * @param options.cwd - The directory to run the command in.
+ * @param options.dev - Whether to install as dev dependency (if not already installed).
+ * @param options.workspace - The name of the workspace to install dependency in (if not already installed).
+ */
+export declare function ensureDependencyInstalled(name: string, options?: Pick<OperationOptions, "cwd" | "dev" | "workspace">): Promise<true | undefined>;
+/**
+ * Dedupe dependencies in the project.
+ *
+ * @param options - Options to pass to the API call.
+ * @param options.cwd - The directory to run the command in.
+ * @param options.packageManager - The package manager info to use (auto-detected).
+ * @param options.silent - Whether to run the command in silent mode.
+ * @param options.recreateLockfile - Whether to recreate the lockfile instead of deduping.
+ */
+export declare function dedupeDependencies(options?: Pick<OperationOptions, "cwd" | "silent" | "packageManager"> & {
+    recreateLockfile?: boolean;
+}): Promise<void>;
+export declare function updateDependencies(latest?: boolean, options?: OperationOptions): Promise<void>;
+/**
+ * Runs a script defined in the package.json file.
+ *
+ * @param name - Name of the script to run.
+ * @param options - Options to pass to the API call.
+ * @param options.cwd - The directory to run the command in.
+ * @param options.silent - Whether to run the command in silent mode.
+ * @param options.packageManager - The package manager info to use (auto-detected).
+ */
+export declare function runScript(name: string, options?: Pick<OperationOptions, "cwd" | "silent" | "packageManager">): Promise<void>;