@ongtrieuhau861457/runner-tailscale-sync 1.260202.11920

package/src/utils/config.js

@@ -0,0 +1,129 @@
+/**
+ * config.js
+ * Load configuration từ .env, CLI flags, và defaults
+ */
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const CONST = require("./constants");
+
+class Config {
+  constructor(options = {}) {
+    // Load .env file nếu có
+    this.loadEnvFile();
+
+    // Determine CWD (priority: CLI flag > env > process.cwd())
+    this.cwd = options.cwd || process.env.TOOL_CWD || process.cwd();
+
+    // Runner data directory
+    this.runnerDataDir = path.join(this.cwd, CONST.RUNNER_DATA_DIR);
+    this.logsDir = path.join(this.runnerDataDir, CONST.LOGS_DIR);
+    this.pidDir = path.join(this.runnerDataDir, CONST.PID_DIR);
+    this.dataServicesDir = path.join(this.runnerDataDir, CONST.DATA_SERVICES_DIR);
+    this.tmpDir = path.join(this.runnerDataDir, CONST.TMP_DIR);
+
+    // Tailscale config
+    this.tailscaleClientId = process.env.TAILSCALE_CLIENT_ID || "";
+    this.tailscaleClientSecret = process.env.TAILSCALE_CLIENT_SECRET || "";
+    this.tailscaleTags = process.env.TAILSCALE_TAGS || CONST.DEFAULT_TAG;
+    this.tailscaleEnable = String(process.env.TAILSCALE_ENABLE || "").trim() === "1";
+
+    // Services to stop on previous runner
+    this.servicesToStop = this.parseServicesList(
+      process.env.SERVICES_TO_STOP || "cloudflared,pocketbase,http-server"
+    );
+
+    // Platform detection
+    this.isWindows = os.platform() === "win32";
+    this.isLinux = os.platform() === "linux";
+    this.isMacOS = os.platform() === "darwin";
+
+    // Logging
+    this.verbose = options.verbose || false;
+    this.quiet = options.quiet || false;
+
+    // Git
+    this.gitEnabled = String(process.env.GIT_PUSH_ENABLED || "1").trim() === "1";
+    this.gitBranch = process.env.GIT_BRANCH || "main";
+
+    // SSH/Rsync paths (for Windows)
+    this.sshPath = process.env.SSH_PATH || "ssh";
+    this.rsyncPath = process.env.RSYNC_PATH || "rsync";
+  }
+
+  /**
+   * Load .env file
+   */
+  loadEnvFile() {
+    const envPath = path.join(process.cwd(), ".env");
+    if (!fs.existsSync(envPath)) return;
+
+    try {
+      const content = fs.readFileSync(envPath, "utf8");
+      content.split("\n").forEach(line => {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) return;
+
+        const match = trimmed.match(/^([^=]+)=(.*)$/);
+        if (match) {
+          const key = match[1].trim();
+          let value = match[2].trim();
+
+          // Remove quotes
+          if ((value.startsWith('"') && value.endsWith('"')) ||
+              (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+          }
+
+          // Only set if not already in env
+          if (!process.env[key]) {
+            process.env[key] = value;
+          }
+        }
+      });
+    } catch (err) {
+      // Ignore errors
+    }
+  }
+
+  /**
+   * Parse comma-separated services list
+   */
+  parseServicesList(str) {
+    return str.split(",").map(s => s.trim()).filter(Boolean);
+  }
+
+  /**
+   * Validate required config
+   */
+  validate() {
+    const errors = [];
+
+    if (this.tailscaleEnable) {
+      if (!this.tailscaleClientId) {
+        errors.push("TAILSCALE_CLIENT_ID is required when TAILSCALE_ENABLE=1");
+      }
+      if (!this.tailscaleClientSecret) {
+        errors.push("TAILSCALE_CLIENT_SECRET is required when TAILSCALE_ENABLE=1");
+      }
+    }
+
+    return errors;
+  }
+
+  /**
+   * Get all directories that need to be created
+   */
+  getDirectoriesToEnsure() {
+    return [
+      this.runnerDataDir,
+      this.logsDir,
+      this.pidDir,
+      this.dataServicesDir,
+      this.tmpDir,
+    ];
+  }
+}
+
+module.exports = Config;

package/src/utils/constants.js

@@ -0,0 +1,33 @@
+/**
+ * constants.js
+ * Định nghĩa các hằng số dùng chung
+ */
+
+module.exports = {
+  // Exit codes
+  EXIT_SUCCESS: 0,
+  EXIT_UNKNOWN: 1,
+  EXIT_VALIDATION: 2,
+  EXIT_NETWORK: 10,
+  EXIT_PROCESS: 20,
+
+  // Directories
+  RUNNER_DATA_DIR: ".runner-data",
+  LOGS_DIR: "logs",
+  PID_DIR: "pid",
+  DATA_SERVICES_DIR: "data-services",
+  TMP_DIR: "tmp",
+
+  // Tailscale
+  DEFAULT_TAG: "tag:ci",
+  CONNECTION_TIMEOUT: 30000,
+  STATUS_CHECK_INTERVAL: 2000,
+
+  // Sync
+  RSYNC_TIMEOUT: 300000, // 5 minutes
+  SSH_TIMEOUT: 60000,    // 1 minute
+
+  // Git
+  GIT_RETRY_COUNT: 3,
+  GIT_RETRY_DELAY: 2000,
+};

package/src/utils/errors.js

@@ -0,0 +1,45 @@
+/**
+ * errors.js
+ * Custom error classes với exit codes
+ */
+
+class BaseError extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = this.constructor.name;
+    this.exitCode = exitCode;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+class ValidationError extends BaseError {
+  constructor(message) {
+    super(message, 2);
+  }
+}
+
+class NetworkError extends BaseError {
+  constructor(message) {
+    super(message, 10);
+  }
+}
+
+class ProcessError extends BaseError {
+  constructor(message) {
+    super(message, 20);
+  }
+}
+
+class SyncError extends BaseError {
+  constructor(message) {
+    super(message, 20);
+  }
+}
+
+module.exports = {
+  BaseError,
+  ValidationError,
+  NetworkError,
+  ProcessError,
+  SyncError,
+};

package/src/utils/logger.js

@@ -0,0 +1,154 @@
+/**
+ * logger.js
+ * Logger với masking sensitive data và version info
+ */
+
+const path = require("path");
+const { getTimestamp } = require("./time");
+
+class Logger {
+  constructor(options = {}) {
+    this.packageName = options.packageName || "runner-tailscale-sync";
+    this.version = options.version || "unknown";
+    this.verbose = options.verbose || false;
+    this.quiet = options.quiet || false;
+    this.command = options.command || "";
+
+    // Danh sách giá trị phổ biến KHÔNG mask
+    this.skipValues = new Set([
+      "true", "false", "TRUE", "FALSE", 
+      "null", "undefined", "NULL",
+      "production", "development", "test", "staging"
+    ]);
+
+    // Danh sách key patterns cần mask
+    this.sensitivePatterns = [
+      "PASSWORD", "SECRET", "KEY", "TOKEN", "API",
+      "CLIENT_ID", "CLIENT_SECRET", "AUTH", "OAUTH",
+      "PRIVATE", "CREDENTIAL", "ACCESS", "PASSPHRASE",
+    ];
+  }
+
+  /**
+   * Mask sensitive values trong message
+   */
+  maskSensitiveData(msg) {
+    let maskedMsg = msg;
+
+    const envValues = Object.entries(process.env)
+      .filter(([key, value]) => {
+        if (!value || typeof value !== "string") return false;
+        const trimmed = value.trim();
+
+        if (trimmed.length < 6) return false;
+        if (this.skipValues.has(trimmed)) return false;
+        if (/^\d+$/.test(trimmed)) return false;
+
+        const upperKey = key.toUpperCase();
+        return this.sensitivePatterns.some(pattern => upperKey.includes(pattern));
+      })
+      .map(([key, value]) => value.trim().replace(/\s+/g, " "))
+      .sort((a, b) => b.length - a.length);
+
+    const uniqueValues = [...new Set(envValues)];
+
+    for (const value of uniqueValues) {
+      const escapedValue = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const whitespacePattern = escapedValue.replace(/\s+/g, "\\s+");
+      const regex = new RegExp(whitespacePattern, "g");
+      maskedMsg = maskedMsg.replace(regex, "*".repeat(value.length));
+    }
+
+    maskedMsg = maskedMsg.replace(/tskey-[a-zA-Z0-9]{30,}/g, "***TAILSCALE_KEY***");
+    maskedMsg = maskedMsg.replace(/ghp_[a-zA-Z0-9]{36}/g, "***GITHUB_TOKEN***");
+    maskedMsg = maskedMsg.replace(/[A-Za-z0-9+/]{32,}={0,2}/g, "***BASE64_SECRET***");
+
+    return maskedMsg;
+  }
+
+  /**
+   * Format message với prefix
+   */
+  format(level, msg) {
+    const timestamp = getTimestamp();
+    const prefix = `[${this.packageName}@${this.version}]`;
+    const commandPrefix = `[${this.command || "unknown"}]`;
+    const timePrefix = `[${timestamp}]`;
+    return `${timePrefix} ${prefix} ${commandPrefix} ${level} ${msg}`;
+  }
+
+  /**
+   * Log info
+   */
+  info(msg) {
+    if (this.quiet) return;
+    const formatted = this.format("ℹ️", msg);
+    const masked = this.maskSensitiveData(formatted);
+    process.stdout.write(masked + "\n");
+  }
+
+  /**
+   * Log success
+   */
+  success(msg) {
+    if (this.quiet) return;
+    const formatted = this.format("✅", msg);
+    const masked = this.maskSensitiveData(formatted);
+    process.stdout.write(masked + "\n");
+  }
+
+  /**
+   * Log warning
+   */
+  warn(msg) {
+    const formatted = this.format("⚠️", msg);
+    const masked = this.maskSensitiveData(formatted);
+    process.stderr.write(masked + "\n");
+  }
+
+  /**
+   * Log error
+   */
+  error(msg) {
+    const formatted = this.format("❌", msg);
+    const masked = this.maskSensitiveData(formatted);
+    process.stderr.write(masked + "\n");
+  }
+
+  /**
+   * Log debug (chỉ khi verbose)
+   */
+  debug(msg) {
+    if (!this.verbose) return;
+    const formatted = this.format("🔍", msg);
+    const masked = this.maskSensitiveData(formatted);
+    process.stdout.write(masked + "\n");
+  }
+
+  /**
+   * Log command execution
+   */
+  command(cmd) {
+    if (this.quiet) return;
+    const formatted = this.format("🔧", cmd);
+    const masked = this.maskSensitiveData(formatted);
+    process.stdout.write(masked + "\n");
+  }
+
+  /**
+   * Print banner khi khởi động
+   */
+  printBanner() {
+    if (this.quiet) return;
+    this.info(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+    this.info(`📦 ${this.packageName} - version ${this.version}`);
+    this.info(`🧾 Đang thực thi version: ${this.version}`);
+    if (this.command) {
+      this.info(`🎯 Command: ${this.command}`);
+    }
+    this.info(`🕐 Started at: ${getTimestamp()} (VN Time)`);
+    this.info(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+  }
+}
+
+module.exports = Logger;

package/src/utils/time.js

@@ -0,0 +1,65 @@
+/**
+ * time.js
+ * Vietnam timezone utilities (Asia/Ho_Chi_Minh)
+ */
+
+const VN_OFFSET = 7 * 60; // UTC+7 in minutes
+
+/**
+ * Lấy thời gian Việt Nam hiện tại
+ * @returns {Date}
+ */
+function getVietnamTime() {
+  const now = new Date();
+  const utc = now.getTime() + (now.getTimezoneOffset() * 60000);
+  return new Date(utc + (VN_OFFSET * 60000));
+}
+
+/**
+ * Format thời gian theo format cụ thể
+ * @param {Date} date 
+ * @param {string} format - 'yyMMdd', 'HHmm', 'yyMMdd-HHmmss', etc
+ * @returns {string}
+ */
+function formatVietnamTime(date, format = 'yyMMdd-HHmmss') {
+  const yy = String(date.getFullYear()).slice(-2);
+  const MM = String(date.getMonth() + 1).padStart(2, '0');
+  const dd = String(date.getDate()).padStart(2, '0');
+  const HH = String(date.getHours()).padStart(2, '0');
+  const mm = String(date.getMinutes()).padStart(2, '0');
+  const ss = String(date.getSeconds()).padStart(2, '0');
+
+  return format
+    .replace('yy', yy)
+    .replace('MM', MM)
+    .replace('dd', dd)
+    .replace('HH', HH)
+    .replace('mm', mm)
+    .replace('ss', ss);
+}
+
+/**
+ * Tạo version string theo format: 1.yyMMdd.1HHmm
+ * @returns {string}
+ */
+function generateVersion() {
+  const vnTime = getVietnamTime();
+  const yyMMdd = formatVietnamTime(vnTime, 'yyMMdd');
+  const HHmm = formatVietnamTime(vnTime, 'HHmm');
+  return `1.${yyMMdd}.1${HHmm}`;
+}
+
+/**
+ * Tạo timestamp string cho logs
+ * @returns {string}
+ */
+function getTimestamp() {
+  return formatVietnamTime(getVietnamTime(), 'yyMMdd-HHmmss');
+}
+
+module.exports = {
+  getVietnamTime,
+  formatVietnamTime,
+  generateVersion,
+  getTimestamp,
+};