@ongtrieuhau861457/runner-tailscale-sync 1.260202.11920

package/src/core/service-controller.js

@@ -0,0 +1,141 @@
+/**
+ * core/service-controller.js
+ * Stop/Start services trên runners qua SSH
+ */
+
+const ssh = require("../adapters/ssh");
+
+/**
+ * Parse input
+ */
+function parseInput(config, previousRunner, logger) {
+  return {
+    remoteHost: previousRunner?.dnsName || previousRunner?.ips?.[0],
+    services: config.servicesToStop,
+    sshPath: config.sshPath,
+    logger,
+  };
+}
+
+/**
+ * Validate
+ */
+function validate(input) {
+  const errors = [];
+
+  if (!input.remoteHost) {
+    errors.push("Remote host is required");
+  }
+
+  if (!input.services || input.services.length === 0) {
+    errors.push("No services specified to stop");
+  }
+
+  return errors;
+}
+
+/**
+ * Plan
+ */
+function plan(input) {
+  return {
+    action: "stop_remote_services",
+    host: input.remoteHost,
+    services: input.services,
+    sshPath: input.sshPath,
+  };
+}
+
+/**
+ * Execute - stop services
+ */
+async function execute(planResult, input) {
+  const { logger } = input;
+
+  logger.info(`Stopping services on ${planResult.host}...`);
+
+  // Check SSH connection first
+  const connected = ssh.checkConnection(planResult.host, {
+    logger,
+    sshPath: planResult.sshPath,
+  });
+
+  if (!connected) {
+    logger.warn(`Cannot connect to ${planResult.host} via SSH - services may still be running`);
+    return {
+      success: false,
+      stoppedServices: [],
+    };
+  }
+
+  // Stop services
+  await ssh.stopServices(planResult.host, planResult.services, {
+    logger,
+    sshPath: planResult.sshPath,
+  });
+
+  return {
+    success: true,
+    stoppedServices: planResult.services,
+  };
+}
+
+/**
+ * Report
+ */
+function report(result, input) {
+  const { logger } = input;
+
+  if (result.success) {
+    logger.success(`Stopped ${result.stoppedServices.length} services`);
+    return {
+      success: true,
+      stoppedServices: result.stoppedServices,
+    };
+  } else {
+    logger.warn("Failed to stop some services");
+    return {
+      success: false,
+      stoppedServices: [],
+    };
+  }
+}
+
+/**
+ * Main stop services function
+ */
+async function stopRemoteServices(config, previousRunner, logger) {
+  if (!previousRunner) {
+    logger.info("No previous runner - skipping service stop");
+    return { success: true, stoppedServices: [] };
+  }
+
+  // Step 1: Parse Input
+  const input = parseInput(config, previousRunner, logger);
+
+  // Step 2: Validate
+  const errors = validate(input);
+  if (errors.length > 0) {
+    // Not critical - just warn
+    logger.warn(`Service stop validation: ${errors.join(", ")}`);
+    return { success: true, stoppedServices: [] };
+  }
+
+  // Step 3: Plan
+  const planResult = plan(input);
+
+  // Step 4: Execute
+  const execResult = await execute(planResult, input);
+
+  // Step 5: Report
+  return report(execResult, input);
+}
+
+module.exports = {
+  stopRemoteServices,
+  parseInput,
+  validate,
+  plan,
+  execute,
+  report,
+};

package/src/core/status.js

@@ -0,0 +1,130 @@
+/**
+ * core/status.js
+ * Show Tailscale status and runner info
+ */
+
+const tailscale = require("../adapters/tailscale");
+const fs_adapter = require("../adapters/fs");
+
+/**
+ * Parse input
+ */
+function parseInput(config, logger) {
+  return {
+    tailscaleEnable: config.tailscaleEnable,
+    tailscaleTags: config.tailscaleTags,
+    runnerDataDir: config.runnerDataDir,
+    logger,
+  };
+}
+
+/**
+ * Validate
+ */
+function validate() {
+  return [];
+}
+
+/**
+ * Plan
+ */
+function plan() {
+  return {
+    action: "status",
+  };
+}
+
+/**
+ * Execute
+ */
+async function execute(planResult, input) {
+  const { logger } = input;
+
+  const result = {
+    tailscale: null,
+    peers: [],
+    peerCount: 0,
+    runnerData: null,
+  };
+
+  if (input.tailscaleEnable) {
+    const status = tailscale.getStatus(logger);
+    result.tailscale = status || null;
+
+    if (status) {
+      result.peerCount = status.Peer ? Object.keys(status.Peer).length : 0;
+      result.peers = tailscale.findPeersWithTag(input.tailscaleTags, logger);
+    }
+  }
+
+  if (fs_adapter.exists(input.runnerDataDir)) {
+    result.runnerData = {
+      path: input.runnerDataDir,
+      size: fs_adapter.getDirSize(input.runnerDataDir),
+    };
+  }
+
+  return result;
+}
+
+/**
+ * Report
+ */
+function report(result, input) {
+  const { logger } = input;
+
+  if (input.tailscaleEnable) {
+    if (result.tailscale) {
+      logger.info("━━━ Tailscale Status ━━━");
+      logger.info(`Backend: ${result.tailscale.BackendState}`);
+
+      if (result.tailscale.Self) {
+        logger.info(`Hostname: ${result.tailscale.Self.HostName || "N/A"}`);
+        logger.info(`DNS: ${result.tailscale.Self.DNSName || "N/A"}`);
+        logger.info(`IPs: ${result.tailscale.Self.TailscaleIPs?.join(", ") || "N/A"}`);
+      }
+
+      if (result.peers.length > 0) {
+        logger.info(`Peers: ${result.peerCount} connected`);
+        logger.info(`Peers with tag '${input.tailscaleTags}':`);
+        result.peers.forEach((peer, i) => {
+          logger.info(`  ${i + 1}. ${peer.hostname} (${peer.ips[0]})`);
+        });
+      }
+    } else {
+      logger.warn("Tailscale not connected");
+    }
+  } else {
+    logger.info("Tailscale disabled");
+  }
+
+  logger.info("━━━ Runner Data ━━━");
+  if (result.runnerData) {
+    logger.info(`Directory: ${result.runnerData.path}`);
+    logger.info(`Size: ${fs_adapter.formatBytes(result.runnerData.size)}`);
+  } else {
+    logger.warn(`Directory not found: ${input.runnerDataDir}`);
+  }
+
+  return { success: true };
+}
+
+/**
+ * Main status function
+ */
+async function showStatus(config, logger) {
+  const input = parseInput(config, logger);
+  validate(input);
+  const planResult = plan(input);
+  const execResult = await execute(planResult, input);
+  return report(execResult, input);
+}
+
+module.exports = {
+  showStatus,
+  parseInput,
+  validate,
+  plan,
+  execute,
+  report,
+};

package/src/core/sync-orchestrator.js

@@ -0,0 +1,260 @@
+/**
+ * core/sync-orchestrator.js
+ * Điều phối toàn bộ quy trình sync
+ */
+
+const tailscale = require("../adapters/tailscale");
+const git = require("../adapters/git");
+const fs_adapter = require("../adapters/fs");
+const runnerDetector = require("./runner-detector");
+const dataSync = require("./data-sync");
+const serviceController = require("./service-controller");
+const { getTimestamp } = require("../utils/time");
+const { ValidationError, ProcessError } = require("../utils/errors");
+
+/**
+ * Parse input
+ */
+function parseInput(config, logger) {
+  return {
+    config,
+    logger,
+  };
+}
+
+/**
+ * Validate
+ */
+function validate(input) {
+  const errors = input.config.validate();
+  if (errors.length > 0) {
+    throw new ValidationError(`Validation failed:\n  - ${errors.join("\n  - ")}`);
+  }
+}
+
+/**
+ * Plan - xác định các bước cần thực hiện
+ */
+function plan(input) {
+  const { config } = input;
+
+  return {
+    steps: [
+      { name: "setup_directories", enabled: true },
+      { name: "connect_tailscale", enabled: config.tailscaleEnable },
+      { name: "detect_previous_runner", enabled: config.tailscaleEnable },
+      { name: "pull_data", enabled: config.tailscaleEnable },
+      { name: "stop_remote_services", enabled: config.tailscaleEnable },
+      { name: "push_to_git", enabled: config.gitEnabled },
+    ],
+  };
+}
+
+/**
+ * Execute - chạy từng bước
+ */
+async function execute(planResult, input) {
+  const { config, logger } = input;
+  const results = {};
+
+  for (const step of planResult.steps) {
+    if (!step.enabled) {
+      logger.debug(`Skipping step: ${step.name}`);
+      continue;
+    }
+
+    logger.info(`━━━ Step: ${step.name} ━━━`);
+
+    try {
+      switch (step.name) {
+        case "setup_directories":
+          results.setupDirs = await setupDirectories(config, logger);
+          break;
+
+        case "connect_tailscale":
+          results.tailscale = await connectTailscale(config, logger);
+          break;
+
+        case "detect_previous_runner":
+          results.detection = await runnerDetector.detectPreviousRunner(config, logger);
+          break;
+
+        case "pull_data":
+          results.pullData = await dataSync.pullData(
+            config,
+            results.detection?.previousRunner,
+            logger
+          );
+          break;
+
+        case "stop_remote_services":
+          results.stopServices = await serviceController.stopRemoteServices(
+            config,
+            results.detection?.previousRunner,
+            logger
+          );
+          break;
+
+        case "push_to_git":
+          results.pushGit = await pushToGit(config, logger);
+          break;
+
+        default:
+          logger.warn(`Unknown step: ${step.name}`);
+      }
+    } catch (err) {
+      logger.error(`Step failed: ${step.name} - ${err.message}`);
+      throw err;
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Report
+ */
+function report(results, input) {
+  const { logger } = input;
+
+  logger.info("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  logger.success("Sync orchestration completed!");
+
+  if (results.tailscale) {
+    logger.info(`Tailscale IP: ${results.tailscale.ip || "N/A"}`);
+    logger.info(`Tailscale Hostname: ${results.tailscale.hostname || "N/A"}`);
+  }
+
+  if (results.detection?.previousRunner) {
+    logger.info(`Previous runner: ${results.detection.previousRunner.hostname}`);
+  }
+
+  if (results.pullData?.syncedSize) {
+    logger.info(`Synced data: ${fs_adapter.formatBytes(results.pullData.syncedSize)}`);
+  }
+
+  if (results.stopServices?.stoppedServices?.length > 0) {
+    logger.info(`Stopped services: ${results.stopServices.stoppedServices.join(", ")}`);
+  }
+
+  logger.info("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+  return {
+    success: true,
+    results,
+  };
+}
+
+/**
+ * Setup directories
+ */
+async function setupDirectories(config, logger) {
+  logger.info("Setting up directories...");
+  
+  const dirs = config.getDirectoriesToEnsure();
+  fs_adapter.ensureDirs(dirs);
+
+  logger.success(`Created ${dirs.length} directories`);
+
+  return {
+    success: true,
+    directories: dirs,
+  };
+}
+
+/**
+ * Connect to Tailscale
+ */
+async function connectTailscale(config, logger) {
+  logger.info("Connecting to Tailscale network...");
+
+  // Install if needed
+  const installed = tailscale.install(logger);
+  if (!installed) {
+    throw new ProcessError("Failed to install Tailscale");
+  }
+
+  // Login
+  await tailscale.login(
+    config.tailscaleClientId,
+    config.tailscaleClientSecret,
+    config.tailscaleTags,
+    logger,
+    config
+  );
+
+  // Get connection info
+  const ip = tailscale.getIP(logger);
+  const hostname = tailscale.getHostname(logger);
+
+  logger.success(`Connected to Tailscale: ${ip || hostname}`);
+
+  return {
+    success: true,
+    ip,
+    hostname,
+  };
+}
+
+/**
+ * Push to git
+ */
+async function pushToGit(config, logger) {
+  logger.info("Pushing data to git repository...");
+
+  if (!git.isAvailable()) {
+    logger.warn("Git not available - skipping push");
+    return { success: false };
+  }
+
+  if (!git.isGitRepo(config.cwd)) {
+    logger.warn("Not a git repository - skipping push");
+    return { success: false };
+  }
+
+  const timestamp = getTimestamp();
+  const message = `[runner-sync] Update .runner-data at ${timestamp}`;
+
+  const pushed = await git.commitAndPush(message, config.gitBranch, {
+    logger,
+    cwd: config.cwd,
+  });
+
+  if (pushed) {
+    logger.success("Pushed to git repository");
+    return { success: true };
+  } else {
+    logger.info("No changes to push");
+    return { success: true, noChanges: true };
+  }
+}
+
+/**
+ * Main orchestrate function
+ */
+async function orchestrate(config, logger) {
+  // Step 1: Parse Input
+  const input = parseInput(config, logger);
+
+  // Step 2: Validate
+  validate(input);
+
+  // Step 3: Plan
+  const planResult = plan(input);
+  logger.debug(`Planned ${planResult.steps.filter(s => s.enabled).length} steps`);
+
+  // Step 4: Execute
+  const execResult = await execute(planResult, input);
+
+  // Step 5: Report
+  return report(execResult, input);
+}
+
+module.exports = {
+  orchestrate,
+  parseInput,
+  validate,
+  plan,
+  execute,
+  report,
+};

package/src/index.js

@@ -0,0 +1,140 @@
+/**
+ * src/index.js
+ * Main library export - cho phép import như library
+ */
+
+const Config = require("./utils/config");
+const Logger = require("./utils/logger");
+const syncOrchestrator = require("./core/sync-orchestrator");
+const runnerDetector = require("./core/runner-detector");
+const dataSync = require("./core/data-sync");
+const serviceController = require("./core/service-controller");
+const initRunner = require("./core/init");
+const pushRunner = require("./core/push");
+const statusRunner = require("./core/status");
+
+// Adapters
+const tailscale = require("./adapters/tailscale");
+const git = require("./adapters/git");
+const ssh = require("./adapters/ssh");
+const fs_adapter = require("./adapters/fs");
+const process_adapter = require("./adapters/process");
+const http_adapter = require("./adapters/http");
+
+// Utils
+const time = require("./utils/time");
+const errors = require("./utils/errors");
+const constants = require("./utils/constants");
+
+/**
+ * Main API - orchestrate full sync
+ */
+async function sync(options = {}) {
+  const config = new Config(options);
+  const pkg = require("../package.json");
+
+  const logger = new Logger({
+    packageName: pkg.name,
+    version: pkg.version,
+    command: "sync",
+    verbose: options.verbose || false,
+    quiet: options.quiet || false,
+  });
+
+  logger.printBanner();
+
+  return await syncOrchestrator.orchestrate(config, logger);
+}
+
+/**
+ * Init only
+ */
+async function init(options = {}) {
+  const config = new Config(options);
+  const pkg = require("../package.json");
+
+  const logger = new Logger({
+    packageName: pkg.name,
+    version: pkg.version,
+    command: "init",
+    verbose: options.verbose || false,
+    quiet: options.quiet || false,
+  });
+
+  logger.printBanner();
+
+  return await initRunner.initRunner(config, logger);
+}
+
+/**
+ * Push to git only
+ */
+async function push(options = {}) {
+  const config = new Config(options);
+  const pkg = require("../package.json");
+
+  const logger = new Logger({
+    packageName: pkg.name,
+    version: pkg.version,
+    command: "push",
+    verbose: options.verbose || false,
+    quiet: options.quiet || false,
+  });
+
+  logger.printBanner();
+
+  return await pushRunner.pushRunnerData(config, logger);
+}
+
+/**
+ * Show status
+ */
+async function status(options = {}) {
+  const config = new Config(options);
+  const pkg = require("../package.json");
+
+  const logger = new Logger({
+    packageName: pkg.name,
+    version: pkg.version,
+    command: "status",
+    verbose: options.verbose || false,
+    quiet: options.quiet || false,
+  });
+
+  logger.printBanner();
+
+  return await statusRunner.showStatus(config, logger);
+}
+
+// Export API và modules
+module.exports = {
+  // Main API
+  sync,
+  init,
+  push,
+  status,
+
+  // Core modules
+  syncOrchestrator,
+  runnerDetector,
+  dataSync,
+  serviceController,
+  initRunner,
+  pushRunner,
+  statusRunner,
+
+  // Adapters
+  tailscale,
+  git,
+  ssh,
+  fs: fs_adapter,
+  process: process_adapter,
+  http: http_adapter,
+
+  // Utils
+  Config,
+  Logger,
+  time,
+  errors,
+  constants,
+};