git-watchtower 1.6.1 → 1.7.0

package/src/config/loader.js

@@ -0,0 +1,329 @@
+/**
+ * Configuration file loading and saving
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { ConfigError } = require('../utils/errors');
+const { getDefaultConfig, validateConfig, migrateConfig } = require('./schema');
+
+/**
+ * Default configuration file name
+ */
+const CONFIG_FILE_NAME = '.watchtowerrc.json';
+
+/**
+ * Get the configuration file path
+ * @param {string} [projectRoot] - Project root directory
+ * @returns {string}
+ */
+function getConfigPath(projectRoot = process.cwd()) {
+  return path.join(projectRoot, CONFIG_FILE_NAME);
+}
+
+/**
+ * Check if configuration file exists
+ * @param {string} [projectRoot] - Project root directory
+ * @returns {boolean}
+ */
+function configExists(projectRoot) {
+  return fs.existsSync(getConfigPath(projectRoot));
+}
+
+/**
+ * Load configuration from file
+ * @param {string} [projectRoot] - Project root directory
+ * @returns {Object|null} - Raw config object or null if not found
+ * @throws {ConfigError} - If file exists but cannot be parsed
+ */
+function loadConfigRaw(projectRoot) {
+  const configPath = getConfigPath(projectRoot);
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw ConfigError.parseError(error);
+    }
+    throw new ConfigError(
+      `Failed to read configuration: ${error.message}`,
+      'CONFIG_READ_ERROR',
+      { path: configPath }
+    );
+  }
+}
+
+/**
+ * Load and validate configuration from file
+ * @param {string} [projectRoot] - Project root directory
+ * @returns {Object|null} - Validated config or null if not found
+ * @throws {ConfigError} - If config is invalid
+ */
+function loadConfig(projectRoot) {
+  const raw = loadConfigRaw(projectRoot);
+
+  if (!raw) {
+    return null;
+  }
+
+  // Migrate old format if needed
+  return migrateConfig(raw);
+}
+
+/**
+ * Save configuration to file
+ * @param {Object} config - Configuration to save
+ * @param {string} [projectRoot] - Project root directory
+ * @throws {ConfigError} - If save fails
+ */
+function saveConfig(config, projectRoot) {
+  const configPath = getConfigPath(projectRoot);
+
+  try {
+    // Validate before saving
+    const validated = validateConfig(config);
+    const content = JSON.stringify(validated, null, 2) + '\n';
+    fs.writeFileSync(configPath, content, 'utf8');
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      throw error;
+    }
+    throw new ConfigError(
+      `Failed to save configuration: ${error.message}`,
+      'CONFIG_WRITE_ERROR',
+      { path: configPath }
+    );
+  }
+}
+
+/**
+ * Delete configuration file
+ * @param {string} [projectRoot] - Project root directory
+ * @returns {boolean} - True if deleted, false if didn't exist
+ */
+function deleteConfig(projectRoot) {
+  const configPath = getConfigPath(projectRoot);
+
+  if (!fs.existsSync(configPath)) {
+    return false;
+  }
+
+  fs.unlinkSync(configPath);
+  return true;
+}
+
+/**
+ * Apply CLI arguments to configuration
+ * CLI args take precedence over config file values
+ * @param {Object} config - Base configuration
+ * @param {Object} cliArgs - CLI arguments
+ * @returns {Object} - Merged configuration
+ */
+function applyCliArgs(config, cliArgs) {
+  const result = JSON.parse(JSON.stringify(config)); // Deep clone
+
+  // Server settings
+  if (cliArgs.mode !== undefined && cliArgs.mode !== null) {
+    result.server.mode = cliArgs.mode;
+  }
+  if (cliArgs.noServer) {
+    result.server.mode = 'none';
+  }
+  if (cliArgs.port !== undefined && cliArgs.port !== null) {
+    result.server.port = cliArgs.port;
+  }
+  if (cliArgs.staticDir !== undefined && cliArgs.staticDir !== null) {
+    result.server.staticDir = cliArgs.staticDir;
+  }
+  if (cliArgs.command !== undefined && cliArgs.command !== null) {
+    result.server.command = cliArgs.command;
+  }
+  if (cliArgs.restartOnSwitch !== undefined && cliArgs.restartOnSwitch !== null) {
+    result.server.restartOnSwitch = cliArgs.restartOnSwitch;
+  }
+
+  // Git settings
+  if (cliArgs.remote !== undefined && cliArgs.remote !== null) {
+    result.remoteName = cliArgs.remote;
+  }
+  if (cliArgs.autoPull !== undefined && cliArgs.autoPull !== null) {
+    result.autoPull = cliArgs.autoPull;
+  }
+  if (cliArgs.pollInterval !== undefined && cliArgs.pollInterval !== null) {
+    result.gitPollInterval = cliArgs.pollInterval;
+  }
+
+  // UI settings
+  if (cliArgs.sound !== undefined && cliArgs.sound !== null) {
+    result.soundEnabled = cliArgs.sound;
+  }
+  if (cliArgs.visibleBranches !== undefined && cliArgs.visibleBranches !== null) {
+    result.visibleBranches = cliArgs.visibleBranches;
+  }
+  if (cliArgs.casino !== undefined && cliArgs.casino !== null) {
+    result.casinoMode = cliArgs.casino;
+  }
+
+  return result;
+}
+
+/**
+ * Parse CLI arguments
+ * @param {string[]} [argv] - Command line arguments (defaults to process.argv.slice(2))
+ * @returns {Object} - Parsed arguments
+ */
+function parseCliArgs(argv = process.argv.slice(2)) {
+  const result = {
+    // Server settings
+    mode: null,
+    noServer: false,
+    port: null,
+    staticDir: null,
+    command: null,
+    restartOnSwitch: null,
+    // Git settings
+    remote: null,
+    autoPull: null,
+    pollInterval: null,
+    // UI settings
+    sound: null,
+    visibleBranches: null,
+    casino: null,
+    // Special flags
+    init: false,
+    help: false,
+    version: false,
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    switch (arg) {
+      // Server settings
+      case '--mode':
+        result.mode = argv[++i];
+        break;
+      case '--no-server':
+        result.noServer = true;
+        break;
+      case '--port':
+      case '-p':
+        result.port = parseInt(argv[++i], 10);
+        break;
+      case '--static-dir':
+        result.staticDir = argv[++i];
+        break;
+      case '--command':
+      case '-c':
+        result.command = argv[++i];
+        break;
+      case '--restart-on-switch':
+        result.restartOnSwitch = true;
+        break;
+      case '--no-restart-on-switch':
+        result.restartOnSwitch = false;
+        break;
+
+      // Git settings
+      case '--remote':
+      case '-r':
+        result.remote = argv[++i];
+        break;
+      case '--auto-pull':
+        result.autoPull = true;
+        break;
+      case '--no-auto-pull':
+        result.autoPull = false;
+        break;
+      case '--poll-interval':
+        result.pollInterval = parseInt(argv[++i], 10) * 1000; // Convert seconds to ms
+        break;
+
+      // UI settings
+      case '--sound':
+        result.sound = true;
+        break;
+      case '--no-sound':
+        result.sound = false;
+        break;
+      case '--visible-branches':
+        result.visibleBranches = parseInt(argv[++i], 10);
+        break;
+      case '--casino':
+        result.casino = true;
+        break;
+      case '--no-casino':
+        result.casino = false;
+        break;
+
+      // Special flags
+      case '--init':
+        result.init = true;
+        break;
+      case '--help':
+      case '-h':
+        result.help = true;
+        break;
+      case '--version':
+      case '-v':
+        result.version = true;
+        break;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Ensure configuration exists
+ * Loads from file, runs wizard if needed, and applies CLI args
+ * @param {Object} cliArgs - CLI arguments
+ * @param {Object} [options] - Options
+ * @param {string} [options.projectRoot] - Project root directory
+ * @param {boolean} [options.interactive=true] - Allow interactive prompts
+ * @param {Function} [options.runWizard] - Wizard function to run if needed
+ * @returns {Promise<Object>} - Final configuration
+ */
+async function ensureConfig(cliArgs, options = {}) {
+  const { projectRoot, interactive = true, runWizard } = options;
+
+  // Check if --init flag was passed (force reconfiguration)
+  if (cliArgs.init && runWizard) {
+    const config = await runWizard();
+    return applyCliArgs(config, cliArgs);
+  }
+
+  // Load existing config
+  let config = loadConfig(projectRoot);
+
+  // If no config exists
+  if (!config) {
+    if (runWizard && interactive && process.stdin.isTTY) {
+      config = await runWizard();
+    } else {
+      // Use defaults
+      config = getDefaultConfig();
+    }
+  }
+
+  // Apply CLI args over config
+  return applyCliArgs(config, cliArgs);
+}
+
+module.exports = {
+  CONFIG_FILE_NAME,
+  getConfigPath,
+  configExists,
+  loadConfigRaw,
+  loadConfig,
+  saveConfig,
+  deleteConfig,
+  applyCliArgs,
+  parseCliArgs,
+  ensureConfig,
+};

package/src/config/schema.js

@@ -0,0 +1,305 @@
+/**
+ * Configuration schema and defaults
+ * Defines the structure and validation for Git Watchtower configuration
+ */
+
+const path = require('path');
+const { ConfigError, ValidationError } = require('../utils/errors');
+
+/**
+ * @typedef {'static' | 'command' | 'none'} ServerMode
+ */
+
+/**
+ * @typedef {Object} ServerConfig
+ * @property {ServerMode} mode - Server mode
+ * @property {string} staticDir - Directory for static files
+ * @property {string} command - Command for command mode
+ * @property {number} port - Server port
+ * @property {boolean} restartOnSwitch - Restart on branch switch
+ */
+
+/**
+ * @typedef {Object} Config
+ * @property {ServerConfig} server - Server configuration
+ * @property {string} remoteName - Git remote name
+ * @property {boolean} autoPull - Auto-pull enabled
+ * @property {number} gitPollInterval - Polling interval in ms
+ * @property {boolean} soundEnabled - Sound notifications enabled
+ * @property {number} visibleBranches - Number of visible branches
+ * @property {boolean} casinoMode - Casino mode enabled
+ */
+
+/**
+ * Valid server modes
+ */
+const SERVER_MODES = ['static', 'command', 'none'];
+
+/**
+ * Configuration defaults
+ * @type {Config}
+ */
+const DEFAULTS = {
+  server: {
+    mode: /** @type {ServerMode} */ ('static'),
+    staticDir: 'public',
+    command: '',
+    port: 3000,
+    restartOnSwitch: true,
+  },
+  remoteName: 'origin',
+  autoPull: true,
+  gitPollInterval: 5000,
+  soundEnabled: true,
+  visibleBranches: 7,
+  casinoMode: false,
+};
+
+/**
+ * Configuration limits
+ */
+const LIMITS = {
+  port: { min: 1, max: 65535 },
+  gitPollInterval: { min: 1000, max: 300000 }, // 1s to 5min
+  visibleBranches: { min: 1, max: 50 },
+};
+
+/**
+ * Get default configuration
+ * @returns {Config}
+ */
+function getDefaultConfig() {
+  return {
+    server: { ...DEFAULTS.server },
+    remoteName: DEFAULTS.remoteName,
+    autoPull: DEFAULTS.autoPull,
+    gitPollInterval: DEFAULTS.gitPollInterval,
+    soundEnabled: DEFAULTS.soundEnabled,
+    visibleBranches: DEFAULTS.visibleBranches,
+    casinoMode: DEFAULTS.casinoMode,
+  };
+}
+
+/**
+ * Validate a port number
+ * @param {*} port - Port to validate
+ * @returns {number}
+ * @throws {ValidationError}
+ */
+function validatePort(port) {
+  const num = Number(port);
+  if (isNaN(num) || !Number.isInteger(num)) {
+    throw ValidationError.invalidPort(port);
+  }
+  if (num < LIMITS.port.min || num > LIMITS.port.max) {
+    throw ValidationError.invalidPort(port);
+  }
+  return num;
+}
+
+/**
+ * Validate server mode
+ * @param {*} mode - Mode to validate
+ * @returns {ServerMode}
+ * @throws {ConfigError}
+ */
+function validateServerMode(mode) {
+  if (!SERVER_MODES.includes(mode)) {
+    throw ConfigError.invalid(
+      `Invalid server mode: "${mode}". Must be one of: ${SERVER_MODES.join(', ')}`,
+      { field: 'server.mode', value: mode, valid: SERVER_MODES }
+    );
+  }
+  return mode;
+}
+
+/**
+ * Validate poll interval
+ * @param {*} interval - Interval to validate
+ * @returns {number}
+ * @throws {ConfigError}
+ */
+function validatePollInterval(interval) {
+  const num = Number(interval);
+  if (isNaN(num) || num < LIMITS.gitPollInterval.min || num > LIMITS.gitPollInterval.max) {
+    throw ConfigError.invalid(
+      `Invalid poll interval: ${interval}. Must be between ${LIMITS.gitPollInterval.min}ms and ${LIMITS.gitPollInterval.max}ms`,
+      { field: 'gitPollInterval', value: interval }
+    );
+  }
+  return Math.round(num);
+}
+
+/**
+ * Validate visible branches count
+ * @param {*} count - Count to validate
+ * @returns {number}
+ * @throws {ConfigError}
+ */
+function validateVisibleBranches(count) {
+  const num = Number(count);
+  if (isNaN(num) || !Number.isInteger(num)) {
+    throw ConfigError.invalid(
+      `Invalid visible branches: ${count}. Must be an integer`,
+      { field: 'visibleBranches', value: count }
+    );
+  }
+  if (num < LIMITS.visibleBranches.min || num > LIMITS.visibleBranches.max) {
+    throw ConfigError.invalid(
+      `Invalid visible branches: ${count}. Must be between ${LIMITS.visibleBranches.min} and ${LIMITS.visibleBranches.max}`,
+      { field: 'visibleBranches', value: count }
+    );
+  }
+  return num;
+}
+
+/**
+ * Validate and normalize a full configuration object
+ * @param {Object} config - Configuration to validate
+ * @returns {Config}
+ * @throws {ConfigError}
+ */
+function validateConfig(config) {
+  if (!config || typeof config !== 'object') {
+    throw ConfigError.invalid('Configuration must be an object');
+  }
+
+  const result = getDefaultConfig();
+
+  // Validate server config
+  if (config.server) {
+    if (typeof config.server !== 'object') {
+      throw ConfigError.invalid('server must be an object');
+    }
+
+    if (config.server.mode !== undefined) {
+      result.server.mode = validateServerMode(config.server.mode);
+    }
+
+    if (config.server.port !== undefined) {
+      result.server.port = validatePort(config.server.port);
+    }
+
+    if (config.server.staticDir !== undefined) {
+      if (typeof config.server.staticDir !== 'string') {
+        throw ConfigError.invalid('server.staticDir must be a string');
+      }
+      // Reject absolute paths and path traversal attempts
+      if (path.isAbsolute(config.server.staticDir)) {
+        throw ConfigError.invalid(
+          'server.staticDir must be a relative path within the project',
+          { field: 'server.staticDir', value: config.server.staticDir }
+        );
+      }
+      const resolved = path.resolve(config.server.staticDir);
+      const cwd = process.cwd();
+      if (!resolved.startsWith(cwd + path.sep) && resolved !== cwd) {
+        throw ConfigError.invalid(
+          'server.staticDir must not escape the project directory',
+          { field: 'server.staticDir', value: config.server.staticDir }
+        );
+      }
+      result.server.staticDir = config.server.staticDir;
+    }
+
+    if (config.server.command !== undefined) {
+      if (typeof config.server.command !== 'string') {
+        throw ConfigError.invalid('server.command must be a string');
+      }
+      // Reject commands containing shell injection patterns
+      const dangerousPatterns = /[|;&`$(){}]|>\s*\/|<\s*\//;
+      if (config.server.command && dangerousPatterns.test(config.server.command)) {
+        throw ConfigError.invalid(
+          'server.command contains potentially dangerous shell characters (|;&`$(){}). ' +
+          'Only simple commands like "npm run dev" are allowed.',
+          { field: 'server.command', value: config.server.command }
+        );
+      }
+      result.server.command = config.server.command;
+    }
+
+    if (config.server.restartOnSwitch !== undefined) {
+      result.server.restartOnSwitch = Boolean(config.server.restartOnSwitch);
+    }
+  }
+
+  // Validate Git settings
+  if (config.remoteName !== undefined) {
+    if (typeof config.remoteName !== 'string' || !config.remoteName.trim()) {
+      throw ConfigError.invalid('remoteName must be a non-empty string');
+    }
+    result.remoteName = config.remoteName.trim();
+  }
+
+  if (config.autoPull !== undefined) {
+    result.autoPull = Boolean(config.autoPull);
+  }
+
+  if (config.gitPollInterval !== undefined) {
+    result.gitPollInterval = validatePollInterval(config.gitPollInterval);
+  }
+
+  // Validate UI settings
+  if (config.soundEnabled !== undefined) {
+    result.soundEnabled = Boolean(config.soundEnabled);
+  }
+
+  if (config.visibleBranches !== undefined) {
+    result.visibleBranches = validateVisibleBranches(config.visibleBranches);
+  }
+
+  if (config.casinoMode !== undefined) {
+    result.casinoMode = Boolean(config.casinoMode);
+  }
+
+  return result;
+}
+
+/**
+ * Migrate old config format to new format
+ * @param {Object} config - Old config
+ * @returns {Config}
+ */
+function migrateConfig(config) {
+  // Already in new format
+  if (config.server) {
+    return validateConfig(config);
+  }
+
+  // Convert old format to new
+  const newConfig = getDefaultConfig();
+
+  if (config.noServer) {
+    newConfig.server.mode = 'none';
+  }
+  if (config.port !== undefined) {
+    newConfig.server.port = validatePort(config.port);
+  }
+  if (config.staticDir !== undefined) {
+    newConfig.server.staticDir = config.staticDir;
+  }
+  if (config.gitPollInterval !== undefined) {
+    newConfig.gitPollInterval = validatePollInterval(config.gitPollInterval);
+  }
+  if (typeof config.soundEnabled === 'boolean') {
+    newConfig.soundEnabled = config.soundEnabled;
+  }
+  if (config.visibleBranches !== undefined) {
+    newConfig.visibleBranches = validateVisibleBranches(config.visibleBranches);
+  }
+
+  return newConfig;
+}
+
+module.exports = {
+  SERVER_MODES,
+  DEFAULTS,
+  LIMITS,
+  getDefaultConfig,
+  validatePort,
+  validateServerMode,
+  validatePollInterval,
+  validateVisibleBranches,
+  validateConfig,
+  migrateConfig,
+};