@ongtrieuhau861457/runner-tailscale-sync 1.260202.11920

package/src/adapters/git.js

@@ -0,0 +1,185 @@
+/**
+ * adapters/git.js
+ * Git operations: push, pull, conflict resolution
+ */
+
+const process_adapter = require("./process");
+const { ProcessError } = require("../utils/errors");
+const CONST = require("../utils/constants");
+
+/**
+ * Check if git is available
+ */
+function isAvailable() {
+  return process_adapter.commandExists("git");
+}
+
+/**
+ * Check if current directory is a git repo
+ */
+function isGitRepo(cwd) {
+  try {
+    const output = process_adapter.runCapture("git rev-parse --git-dir", { cwd });
+    return output !== null;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Add files to git
+ */
+function add(files, options = {}) {
+  const { logger, cwd } = options;
+
+  const filesStr = Array.isArray(files) ? files.join(" ") : files;
+  const cmd = `git add ${filesStr}`;
+
+  try {
+    process_adapter.run(cmd, { logger, cwd, ignoreError: false });
+    return true;
+  } catch (err) {
+    throw new ProcessError(`Git add failed: ${err.message}`);
+  }
+}
+
+/**
+ * Commit changes
+ */
+function commit(message, options = {}) {
+  const { logger, cwd } = options;
+
+  const safeMessage = message.replace(/"/g, '\\"');
+  const cmd = `git commit -m "${safeMessage}"`;
+
+  try {
+    process_adapter.run(cmd, { logger, cwd, ignoreError: false });
+    return true;
+  } catch (err) {
+    // No changes to commit is OK
+    if (err.message && err.message.includes("nothing to commit")) {
+      if (logger) {
+        logger.debug("No changes to commit");
+      }
+      return false;
+    }
+    throw new ProcessError(`Git commit failed: ${err.message}`);
+  }
+}
+
+/**
+ * Push to remote
+ */
+async function push(branch, options = {}) {
+  const { logger, cwd, retries = CONST.GIT_RETRY_COUNT } = options;
+
+  const cmd = `git push origin ${branch}`;
+
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      process_adapter.run(cmd, { logger, cwd, ignoreError: false });
+      if (logger) {
+        logger.success(`Pushed to ${branch}`);
+      }
+      return true;
+    } catch (err) {
+      if (attempt < retries) {
+        if (logger) {
+          logger.warn(`Push failed (attempt ${attempt}/${retries}), retrying...`);
+        }
+        await process_adapter.sleep(CONST.GIT_RETRY_DELAY);
+      } else {
+        throw new ProcessError(`Git push failed after ${retries} attempts: ${err.message}`);
+      }
+    }
+  }
+}
+
+/**
+ * Pull from remote
+ */
+async function pull(branch, options = {}) {
+  const { logger, cwd, retries = CONST.GIT_RETRY_COUNT } = options;
+
+  const cmd = `git pull origin ${branch}`;
+
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      process_adapter.run(cmd, { logger, cwd, ignoreError: false });
+      if (logger) {
+        logger.success(`Pulled from ${branch}`);
+      }
+      return true;
+    } catch (err) {
+      if (attempt < retries) {
+        if (logger) {
+          logger.warn(`Pull failed (attempt ${attempt}/${retries}), retrying...`);
+        }
+        await process_adapter.sleep(CONST.GIT_RETRY_DELAY);
+      } else {
+        throw new ProcessError(`Git pull failed after ${retries} attempts: ${err.message}`);
+      }
+    }
+  }
+}
+
+/**
+ * Get current branch
+ */
+function getCurrentBranch(cwd) {
+  try {
+    return process_adapter.runCapture("git rev-parse --abbrev-ref HEAD", { cwd });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if there are uncommitted changes
+ */
+function hasUncommittedChanges(cwd) {
+  try {
+    const output = process_adapter.runCapture("git status --porcelain", { cwd });
+    return output && output.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Full workflow: add, commit, push
+ */
+async function commitAndPush(message, branch, options = {}) {
+  const { logger, cwd } = options;
+
+  if (!hasUncommittedChanges(cwd)) {
+    if (logger) {
+      logger.info("No changes to commit");
+    }
+    return false;
+  }
+
+  // Add all changes in .runner-data
+  add(".runner-data/*", { logger, cwd });
+
+  // Commit
+  const committed = commit(message, { logger, cwd });
+  if (!committed) return false;
+
+  // Push
+  await push(branch, { logger, cwd });
+
+  return true;
+}
+
+module.exports = {
+  isAvailable,
+  isGitRepo,
+  add,
+  commit,
+  push,
+  pull,
+  getCurrentBranch,
+  hasUncommittedChanges,
+  commitAndPush,
+};

package/src/adapters/http.js

@@ -0,0 +1,56 @@
+/**
+ * adapters/http.js
+ * HTTP fetch with timeout + retry
+ */
+
+const { NetworkError } = require("../utils/errors");
+
+async function fetchWithTimeout(url, options = {}) {
+  const { timeoutMs = 10000, ...rest } = options;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(url, {
+      ...rest,
+      signal: controller.signal,
+    });
+    return response;
+  } catch (err) {
+    if (err.name === "AbortError") {
+      throw new NetworkError(`Request timeout after ${timeoutMs}ms: ${url}`);
+    }
+    throw new NetworkError(`Request failed: ${err.message}`);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function fetchWithRetry(url, options = {}) {
+  const {
+    retries = 3,
+    retryDelayMs = 1000,
+    timeoutMs = 10000,
+    ...rest
+  } = options;
+
+  let lastError;
+
+  for (let attempt = 1; attempt <= retries; attempt += 1) {
+    try {
+      return await fetchWithTimeout(url, { ...rest, timeoutMs });
+    } catch (err) {
+      lastError = err;
+      if (attempt < retries) {
+        await new Promise(resolve => setTimeout(resolve, retryDelayMs));
+      }
+    }
+  }
+
+  throw lastError || new NetworkError(`Request failed after ${retries} attempts: ${url}`);
+}
+
+module.exports = {
+  fetchWithTimeout,
+  fetchWithRetry,
+};

package/src/adapters/process.js

@@ -0,0 +1,151 @@
+/**
+ * adapters/process.js
+ * Cross-platform process spawning
+ */
+
+const { execSync, spawn } = require("child_process");
+const os = require("os");
+
+const isWindows = os.platform() === "win32";
+
+/**
+ * Run command và wait for completion
+ */
+function run(cmd, options = {}) {
+  const { ignoreError = false, cwd, logger } = options;
+
+  if (logger) {
+    logger.command(cmd);
+  }
+
+  try {
+    return execSync(cmd, {
+      stdio: "inherit",
+      cwd: cwd || process.cwd(),
+      ...options,
+    });
+  } catch (err) {
+    if (ignoreError) {
+      if (logger) {
+        logger.warn(`Command failed (ignored): ${cmd}`);
+      }
+      return null;
+    }
+    throw err;
+  }
+}
+
+/**
+ * Run command và capture output
+ */
+function runCapture(cmd, options = {}) {
+  const { cwd } = options;
+
+  try {
+    return execSync(cmd, {
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8",
+      cwd: cwd || process.cwd(),
+      ...options,
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if command exists
+ */
+function commandExists(cmd) {
+  const check = isWindows ? `where ${cmd}` : `command -v ${cmd}`;
+  return !!runCapture(check);
+}
+
+/**
+ * Run command with timeout
+ */
+function runWithTimeout(cmd, timeoutMs, options = {}) {
+  const { logger } = options;
+
+  // Support both string commands and argv arrays.
+  // - If cmd is an array: [exe, ...args] -> spawn(exe, args)
+  // - If cmd is a string: spawn(cmd, { shell: true }) so quoting works cross-platform
+  const useArray = Array.isArray(cmd);
+
+  return new Promise((resolve, reject) => {
+    const spawnOptions = {
+      stdio: "inherit",
+      cwd: options.cwd || process.cwd(),
+      detached: !isWindows,
+    };
+    const child = useArray
+      ? spawn(cmd[0], cmd.slice(1), spawnOptions)
+      : spawn(cmd, { ...spawnOptions, shell: true });
+
+    const timer = setTimeout(() => {
+      if (isWindows) {
+        try {
+          execSync(`taskkill /pid ${child.pid} /T /F`);
+        } catch (err) {
+          if (logger) {
+            logger.warn(`Failed to terminate process tree: ${err.message}`);
+          }
+        }
+      } else {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch (err) {
+          if (logger) {
+            logger.warn(`Failed to terminate process group: ${err.message}`);
+          }
+        }
+      }
+      reject(new Error(`Command timeout after ${timeoutMs}ms: ${useArray ? cmd.join(" ") : cmd}`));
+    }, timeoutMs);
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+
+      if (code === 0) {
+        resolve(true);
+      } else {
+        reject(new Error(`Command failed with code ${code}: ${useArray ? cmd.join(" ") : cmd}`));
+      }
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+
+/**
+ * Sleep
+ */
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Wait for condition
+ */
+async function waitForCondition(checkFn, timeoutMs = 30000, intervalMs = 1000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (checkFn()) return true;
+    await sleep(intervalMs);
+  }
+  return false;
+}
+
+module.exports = {
+  run,
+  runCapture,
+  commandExists,
+  runWithTimeout,
+  sleep,
+  waitForCondition,
+  isWindows,
+};

package/src/adapters/ssh.js

@@ -0,0 +1,103 @@
+/**
+ * adapters/ssh.js
+ * SSH operations: execute commands remotely
+ */
+
+const process_adapter = require("./process");
+const { ProcessError } = require("../utils/errors");
+const CONST = require("../utils/constants");
+
+/**
+ * Execute command via SSH
+ */
+function executeCommand(host, command, options = {}) {
+  const { logger, sshPath = "ssh", timeout = CONST.SSH_TIMEOUT } = options;
+
+  // If sshPath contains spaces, spawn can still execute it if provided as argv[0].
+  // Avoid building a single shell string to keep quoting predictable.
+  const sshArgs = ["-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=10", host, command];
+
+  if (logger) {
+    logger.command([sshPath, ...sshArgs].join(" "));
+  }
+
+  return process_adapter.runWithTimeout([sshPath, ...sshArgs], timeout, { logger });
+}
+
+/**
+ * Execute command và capture output
+ */
+function executeCommandCapture(host, command, options = {}) {
+  const { sshPath = "ssh" } = options;
+
+  const sshCmd = `${sshPath} -o StrictHostKeyChecking=no -o ConnectTimeout=10 ${host} "${command}"`;
+
+  try {
+    return process_adapter.runCapture(sshCmd);
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Check if SSH connection works
+ */
+function checkConnection(host, options = {}) {
+  const { logger, sshPath = "ssh" } = options;
+
+  if (logger) {
+    logger.debug(`Testing SSH connection to ${host}...`);
+  }
+
+  try {
+    const result = executeCommandCapture(host, "echo OK", { sshPath });
+    return result === "OK";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Stop services on remote host
+ */
+async function stopServices(host, services, options = {}) {
+  const { logger, sshPath = "ssh" } = options;
+
+  if (!services || services.length === 0) {
+    if (logger) {
+      logger.info("No services to stop");
+    }
+    return;
+  }
+
+  logger.info(`Stopping services on ${host}: ${services.join(", ")}`);
+
+  await Promise.all(
+    services.map(async (service) => {
+      try {
+        await executeCommand(host, `sudo systemctl stop ${service}`, {
+          logger,
+          sshPath,
+        });
+        logger.success(`Stopped service: ${service}`);
+      } catch (err) {
+        try {
+          await executeCommand(host, `pkill -f ${service}`, {
+            logger,
+            sshPath,
+          });
+          logger.success(`Killed process: ${service}`);
+        } catch (err2) {
+          logger.warn(`Failed to stop ${service}: ${err2.message}`);
+        }
+      }
+    }),
+  );
+}
+
+module.exports = {
+  executeCommand,
+  executeCommandCapture,
+  checkConnection,
+  stopServices,
+};