refactor: rename builders to server

packages/server/src/utils/process/execAsync.ts

@@ -0,0 +1,70 @@
+import { exec } from "node:child_process";
+import util from "node:util";
+import { findServerById } from "@/server/services/server";
+import { Client } from "ssh2";
+export const execAsync = util.promisify(exec);
+
+export const execAsyncRemote = async (
+	serverId: string | null,
+	command: string,
+): Promise<{ stdout: string; stderr: string }> => {
+	if (!serverId) return { stdout: "", stderr: "" };
+	const server = await findServerById(serverId);
+	if (!server.sshKeyId) throw new Error("No SSH key available for this server");
+
+	let stdout = "";
+	let stderr = "";
+	return new Promise((resolve, reject) => {
+		const conn = new Client();
+
+		sleep(1000);
+		conn
+			.once("ready", () => {
+				conn.exec(command, (err, stream) => {
+					if (err) throw err;
+					stream
+						.on("close", (code: number, signal: string) => {
+							conn.end();
+							if (code === 0) {
+								resolve({ stdout, stderr });
+							} else {
+								reject(
+									new Error(
+										`Command exited with code ${code}. Stderr: ${stderr}, command: ${command}`,
+									),
+								);
+							}
+						})
+						.on("data", (data: string) => {
+							stdout += data.toString();
+						})
+						.stderr.on("data", (data) => {
+							stderr += data.toString();
+						});
+				});
+			})
+			.on("error", (err) => {
+				conn.end();
+				if (err.level === "client-authentication") {
+					reject(
+						new Error(
+							`Authentication failed: Invalid SSH private key. ❌ Error: ${err.message} ${err.level}`,
+						),
+					);
+				} else {
+					reject(new Error(`SSH connection error: ${err.message}`));
+				}
+			})
+			.connect({
+				host: server.ipAddress,
+				port: server.port,
+				username: server.username,
+				privateKey: server.sshKey?.privateKey,
+				timeout: 99999,
+			});
+	});
+};
+
+export const sleep = (ms: number) => {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+};

packages/server/src/utils/process/spawnAsync.ts

@@ -0,0 +1,58 @@
+import {
+	type ChildProcess,
+	type SpawnOptions,
+	spawn,
+} from "node:child_process";
+import BufferList from "bl";
+
+export const spawnAsync = (
+	command: string,
+	args?: string[] | undefined,
+	onData?: (data: string) => void, // Callback opcional para manejar datos en tiempo real
+	options?: SpawnOptions,
+): Promise<BufferList> & { child: ChildProcess } => {
+	const child = spawn(command, args ?? [], options ?? {});
+	const stdout = child.stdout ? new BufferList() : new BufferList();
+	const stderr = child.stderr ? new BufferList() : new BufferList();
+
+	if (child.stdout) {
+		child.stdout.on("data", (data) => {
+			stdout.append(data);
+			if (onData) {
+				onData(data.toString());
+			}
+		});
+	}
+	if (child.stderr) {
+		child.stderr.on("data", (data) => {
+			stderr.append(data);
+			if (onData) {
+				onData(data.toString());
+			}
+		});
+	}
+
+	const promise = new Promise<BufferList>((resolve, reject) => {
+		child.on("error", reject);
+
+		child.on("close", (code) => {
+			if (code === 0) {
+				resolve(stdout);
+			} else {
+				const err = new Error(`${stderr.toString()}`) as Error & {
+					code: number;
+					stderr: BufferList;
+					stdout: BufferList;
+				};
+				err.code = code || -1;
+				err.stderr = stderr;
+				err.stdout = stdout;
+				reject(err);
+			}
+		});
+	}) as Promise<BufferList> & { child: ChildProcess };
+
+	promise.child = child;
+
+	return promise;
+};