@involvex/msix-packager-cli 1.4.1

package/src/utils.js

@@ -0,0 +1,292 @@
+const path = require("path");
+const fs = require("fs-extra");
+const { execSync } = require("child_process");
+const https = require("https");
+const { CONSTANTS, ToolNotFoundError, MSIXError } = require("./constants");
+
+/**
+ * Executes a command safely with error handling
+ * @param {string} command - Command to execute
+ * @param {Object} options - Execution options
+ * @returns {string} Command output
+ * @throws {MSIXError} When command execution fails
+ */
+function executeCommand(command, options = {}) {
+  try {
+    const result = execSync(command, {
+      encoding: "utf8",
+      stdio: options.silent ? "pipe" : "inherit",
+      windowsHide: true,
+      ...options,
+    });
+    return result;
+  } catch (error) {
+    const errorMessage = `Command failed: ${command}\n${error.message}`;
+    throw new MSIXError(errorMessage);
+  }
+}
+
+/**
+ * Finds Windows SDK tools
+ * @returns {Object} Object containing paths to makeappx and signtool
+ * @throws {ToolNotFoundError} When tools are not found
+ */
+function findWindowsSDKTools() {
+  const possiblePaths = CONSTANTS.WINDOWS_SDK_PATHS;
+
+  for (const basePath of possiblePaths) {
+    try {
+      const makeappxPath = path.join(basePath, "makeappx.exe");
+      const signtoolPath = path.join(basePath, "signtool.exe");
+
+      if (fs.existsSync(makeappxPath) && fs.existsSync(signtoolPath)) {
+        return {
+          makeappx: makeappxPath,
+          signtool: signtoolPath,
+        };
+      }
+    } catch (error) {
+      // Continue searching
+    }
+  }
+
+  throw new ToolNotFoundError(
+    "Windows SDK tools (makeappx.exe, signtool.exe) not found. Please install Windows SDK.",
+  );
+}
+
+/**
+ * Generates a unique temporary directory name
+ * @param {string} prefix - Prefix for the temporary directory
+ * @returns {string} Temporary directory path
+ */
+function getTempDir(prefix = "msix-temp") {
+  const tempBase =
+    process.env.TEMP || process.env.TMP || path.join(process.cwd(), "temp");
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  return path.join(tempBase, `${prefix}-${timestamp}-${random}`);
+}
+
+/**
+ * Cleans up temporary directories and files
+ * @param {string[]} paths - Array of paths to clean up
+ */
+async function cleanup(paths) {
+  for (const cleanupPath of paths) {
+    try {
+      if (await fs.pathExists(cleanupPath)) {
+        await fs.remove(cleanupPath);
+        console.log(`Cleaned up: ${cleanupPath}`);
+      }
+    } catch (error) {
+      console.warn(
+        `Warning: Could not clean up ${cleanupPath}: ${error.message}`,
+      );
+    }
+  }
+}
+
+/**
+ * Creates a directory structure ensuring all parent directories exist
+ * @param {string} dirPath - Directory path to create
+ */
+async function ensureDir(dirPath) {
+  try {
+    await fs.ensureDir(dirPath);
+  } catch (error) {
+    throw new MSIXError(
+      `Failed to create directory ${dirPath}: ${error.message}`,
+    );
+  }
+}
+
+/**
+ * Copies files with progress indication
+ * @param {string} src - Source path
+ * @param {string} dest - Destination path
+ * @param {boolean} showProgress - Whether to show progress
+ */
+async function copyFiles(src, dest, showProgress = true) {
+  try {
+    if (showProgress) {
+      console.log(`Copying files from ${src} to ${dest}...`);
+    }
+
+    await fs.copy(src, dest, {
+      overwrite: true,
+      errorOnExist: false,
+      filter: (src) => {
+        // Skip node_modules and common temporary directories
+        const relativePath = path.relative(src, src);
+        return !CONSTANTS.COPY_EXCLUDE_PATTERNS.some((pattern) =>
+          relativePath.includes(pattern),
+        );
+      },
+    });
+
+    if (showProgress) {
+      console.log("Files copied successfully");
+    }
+  } catch (error) {
+    throw new MSIXError(`Failed to copy files: ${error.message}`);
+  }
+}
+
+/**
+ * Reads and parses package.json from a directory
+ * @param {string} directoryPath - Path to directory containing package.json
+ * @returns {Object} Parsed package.json content
+ * @throws {MSIXError} When package.json cannot be read or parsed
+ */
+async function readPackageJson(directoryPath) {
+  const packageJsonPath = path.join(directoryPath, "package.json");
+
+  try {
+    const content = await fs.readFile(packageJsonPath, "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new MSIXError(
+      `Failed to read package.json from ${directoryPath}: ${error.message}`,
+    );
+  }
+}
+
+/**
+ * Formats file size for human reading
+ * @param {number} bytes - Size in bytes
+ * @returns {string} Formatted size string
+ */
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 Bytes";
+
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+
+/**
+ * Validates that all required tools are available
+ * @throws {ToolNotFoundError} When required tools are missing
+ */
+function validateRequiredTools() {
+  try {
+    // Check for Node.js
+    execSync("node --version", { stdio: "pipe" });
+  } catch {
+    throw new ToolNotFoundError("Node.js is required but not found in PATH");
+  }
+
+  try {
+    // Check for bun
+    execSync("bun --version", { stdio: "pipe" });
+  } catch {
+    throw new ToolNotFoundError("bun is required but not found in PATH");
+  }
+
+  // Check for Windows SDK tools
+  findWindowsSDKTools(); // This will throw if not found
+}
+
+/**
+ * Gets system information for debugging
+ * @returns {Object} System information
+ */
+function getSystemInfo() {
+  try {
+    const nodeVersion = execSync("node --version", { encoding: "utf8" }).trim();
+    const bunVersion = execSync("bun --version", { encoding: "utf8" }).trim();
+    const osVersion = require("os").release();
+    const platform = process.platform;
+    const arch = process.arch;
+
+    return {
+      node: nodeVersion,
+      bun: bunVersion,
+      os: osVersion,
+      platform,
+      architecture: arch,
+      timestamp: new Date().toISOString(),
+    };
+  } catch (error) {
+    return {
+      error: "Could not gather system information",
+      timestamp: new Date().toISOString(),
+    };
+  }
+}
+
+/**
+ * Gets the latest Node.js LTS version dynamically
+ * @returns {Promise<string>} Latest LTS version (e.g., 'v22.8.0')
+ */
+async function getLatestNodeVersion() {
+  try {
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: "nodejs.org",
+        path: "/dist/index.json",
+        method: "GET",
+        timeout: 10000,
+      };
+
+      const req = https.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            const releases = JSON.parse(data);
+            // Find latest LTS version
+            const latestLTS = releases.find((release) => release.lts);
+            if (latestLTS) {
+              resolve(latestLTS.version);
+            } else {
+              // Fallback to latest stable
+              resolve(releases[0].version);
+            }
+          } catch (parseError) {
+            console.warn(
+              "Warning: Could not parse Node.js releases, using fallback version",
+            );
+            resolve("v22.8.0"); // Fallback version
+          }
+        });
+      });
+
+      req.on("error", (error) => {
+        console.warn(
+          "Warning: Could not fetch latest Node.js version, using fallback",
+        );
+        resolve("v22.8.0"); // Fallback version
+      });
+
+      req.on("timeout", () => {
+        console.warn(
+          "Warning: Timeout fetching Node.js version, using fallback",
+        );
+        resolve("v22.8.0"); // Fallback version
+      });
+
+      req.end();
+    });
+  } catch (error) {
+    console.warn("Warning: Error getting Node.js version, using fallback");
+    return "v22.8.0"; // Fallback version
+  }
+}
+
+module.exports = {
+  executeCommand,
+  findWindowsSDKTools,
+  getTempDir,
+  cleanup,
+  ensureDir,
+  copyFiles,
+  readPackageJson,
+  formatFileSize,
+  validateRequiredTools,
+  getSystemInfo,
+  getLatestNodeVersion,
+};

package/src/validation.js

@@ -0,0 +1,228 @@
+const path = require("path");
+const fs = require("fs-extra");
+const { CONSTANTS, ValidationError } = require("./constants");
+
+/**
+ * Validates configuration object for MSIX package creation
+ * @param {Object} config - Configuration object to validate
+ * @throws {ValidationError} When validation fails
+ */
+function validateConfig(config) {
+  const errors = [];
+
+  // Required fields
+  const requiredFields = [
+    { field: "inputPath", type: "string" },
+    { field: "outputPath", type: "string" },
+    { field: "appName", type: "string" },
+    { field: "publisher", type: "string" },
+  ];
+
+  for (const { field, type } of requiredFields) {
+    if (!config[field]) {
+      errors.push(`Missing required field: ${field}`);
+    } else if (typeof config[field] !== type) {
+      errors.push(
+        `Field ${field} must be of type ${type}, got ${typeof config[field]}`,
+      );
+    }
+  }
+
+  // Validate publisher format
+  if (config.publisher && !CONSTANTS.PUBLISHER_PATTERN.test(config.publisher)) {
+    errors.push('Publisher must start with "CN=" (e.g., "CN=MyCompany")');
+  }
+
+  // Validate version format
+  if (config.version) {
+    if (!CONSTANTS.VERSION_PATTERN.test(config.version)) {
+      errors.push('Version must be in format x.x.x.x (e.g., "1.0.0.0")');
+    }
+  }
+
+  // Validate architecture
+  if (
+    config.architecture &&
+    !CONSTANTS.SUPPORTED_ARCHITECTURES.includes(config.architecture)
+  ) {
+    errors.push(
+      `Architecture must be one of: ${CONSTANTS.SUPPORTED_ARCHITECTURES.join(", ")}`,
+    );
+  }
+
+  // Validate package name length
+  if (
+    config.packageName &&
+    config.packageName.length > CONSTANTS.MAX_PACKAGE_NAME_LENGTH
+  ) {
+    errors.push(
+      `Package name must be ${CONSTANTS.MAX_PACKAGE_NAME_LENGTH} characters or less`,
+    );
+  }
+
+  // Validate capabilities
+  if (config.capabilities && !Array.isArray(config.capabilities)) {
+    errors.push("Capabilities must be an array");
+  }
+
+  if (errors.length > 0) {
+    throw new ValidationError(
+      "config",
+      "valid configuration object",
+      errors.join("; "),
+    );
+  }
+}
+
+/**
+ * Validates that required paths exist
+ * @param {Object} config - Configuration object
+ * @throws {ValidationError} When paths don't exist
+ */
+async function validatePaths(config) {
+  const errors = [];
+
+  // Check input path exists
+  if (!(await fs.pathExists(config.inputPath))) {
+    errors.push(`Input path does not exist: ${config.inputPath}`);
+  } else {
+    // Check if it's a directory
+    const stats = await fs.stat(config.inputPath);
+    if (!stats.isDirectory()) {
+      errors.push(`Input path must be a directory: ${config.inputPath}`);
+    }
+
+    // Check for package.json in input directory
+    const packageJsonPath = path.join(config.inputPath, "package.json");
+    if (!(await fs.pathExists(packageJsonPath))) {
+      errors.push(
+        `No package.json found in input directory: ${config.inputPath}`,
+      );
+    }
+  }
+
+  // Validate icon path if provided
+  if (config.icon && !(await fs.pathExists(config.icon))) {
+    errors.push(`Icon file does not exist: ${config.icon}`);
+  }
+
+  if (errors.length > 0) {
+    throw new ValidationError("paths", "existing paths", errors.join("; "));
+  }
+}
+
+/**
+ * Sanitizes configuration values
+ * @param {Object} config - Configuration object to sanitize
+ * @returns {Object} Sanitized configuration
+ */
+function sanitizeConfig(config) {
+  const sanitized = { ...config };
+
+  // Set defaults
+  sanitized.version = sanitized.version || CONSTANTS.DEFAULT_VERSION;
+  sanitized.architecture =
+    sanitized.architecture || CONSTANTS.DEFAULT_ARCHITECTURE;
+  sanitized.executable = sanitized.executable || CONSTANTS.DEFAULT_EXECUTABLE;
+  sanitized.timestampUrl =
+    sanitized.timestampUrl || CONSTANTS.DEFAULT_TIMESTAMP_URL;
+  sanitized.capabilities =
+    sanitized.capabilities || CONSTANTS.DEFAULT_CAPABILITIES;
+
+  // Sanitize strings
+  sanitized.appName = sanitized.appName.trim();
+  sanitized.publisher = sanitized.publisher.trim();
+
+  // Generate package name if not provided
+  if (!sanitized.packageName) {
+    const publisherName = sanitized.publisher
+      .replace(/^CN=/, "")
+      .split(",")[0]
+      .trim();
+    const appNameSafe = sanitized.appName.replace(/[^a-zA-Z0-9]/g, "");
+    sanitized.packageName = `${publisherName}.${appNameSafe}`.substring(
+      0,
+      CONSTANTS.MAX_PACKAGE_NAME_LENGTH,
+    );
+  }
+
+  // Generate display name if not provided
+  sanitized.displayName = sanitized.displayName || sanitized.appName;
+
+  // Set description if not provided
+  sanitized.description =
+    sanitized.description ||
+    `${sanitized.appName} - Node.js application packaged as MSIX`;
+
+  // Set build options
+  sanitized.skipBuild = sanitized.skipBuild || false;
+  sanitized.installDevDeps = sanitized.installDevDeps !== false; // Default to true
+
+  // Normalize paths
+  sanitized.inputPath = path.resolve(sanitized.inputPath);
+  sanitized.outputPath = path.resolve(sanitized.outputPath);
+
+  if (sanitized.icon) {
+    sanitized.icon = path.resolve(sanitized.icon);
+  }
+
+  return sanitized;
+}
+
+/**
+ * Validates certificate configuration
+ * @param {Object} signingConfig - Signing configuration
+ * @throws {ValidationError} When signing configuration is invalid
+ */
+function validateSigningConfig(signingConfig) {
+  if (!signingConfig.sign) {
+    return; // No validation needed if signing is disabled
+  }
+
+  const errors = [];
+
+  // At least one certificate identification method should be provided
+  const hasCertId =
+    signingConfig.certificateThumbprint ||
+    signingConfig.certificateSubject ||
+    signingConfig.certificatePath;
+
+  if (!hasCertId) {
+    // This is okay - we'll auto-discover certificates
+    return;
+  }
+
+  // If certificatePath is provided, check if password is needed
+  if (signingConfig.certificatePath && !signingConfig.certificatePassword) {
+    // Warning but not error - some PFX files don't need passwords
+  }
+
+  // Validate thumbprint format if provided
+  if (signingConfig.certificateThumbprint) {
+    const thumbprintPattern = /^[A-Fa-f0-9]{40}$/;
+    if (
+      !thumbprintPattern.test(
+        signingConfig.certificateThumbprint.replace(/\s/g, ""),
+      )
+    ) {
+      errors.push(
+        "Certificate thumbprint must be a 40-character hexadecimal string",
+      );
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new ValidationError(
+      "signingConfig",
+      "valid signing configuration",
+      errors.join("; "),
+    );
+  }
+}
+
+module.exports = {
+  validateConfig,
+  validatePaths,
+  sanitizeConfig,
+  validateSigningConfig,
+};