@dagu-org/dagu 1.17.4 → 1.22.10

package/lib/platform.js

@@ -1,30 +1,29 @@
-const os = require('os');
-const path = require('path');
-const fs = require('fs');
+const path = require("path");
+const fs = require("fs");
 
 // Platform mapping from Node.js to npm package names
 const PLATFORM_MAP = {
   // Tier 1 - Most common platforms
-  'linux-x64': '@dagu-org/dagu-linux-x64',
-  'linux-arm64': '@dagu-org/dagu-linux-arm64',
-  'darwin-x64': '@dagu-org/dagu-darwin-x64',
-  'darwin-arm64': '@dagu-org/dagu-darwin-arm64',
-  'win32-x64': '@dagu-org/dagu-win32-x64',
-  
+  "linux-x64": "dagu-linux-x64",
+  "linux-arm64": "dagu-linux-arm64",
+  "darwin-x64": "dagu-darwin-x64",
+  "darwin-arm64": "dagu-darwin-arm64",
+  "win32-x64": "dagu-win32-x64",
+
   // Tier 2 - Common but less frequent
-  'linux-ia32': '@dagu-org/dagu-linux-ia32',
-  'win32-ia32': '@dagu-org/dagu-win32-ia32',
-  'freebsd-x64': '@dagu-org/dagu-freebsd-x64',
-  
+  "linux-ia32": "dagu-linux-ia32",
+  "win32-ia32": "dagu-win32-ia32",
+  "freebsd-x64": "dagu-freebsd-x64",
+
   // Tier 3 - Rare platforms
-  'win32-arm64': '@dagu-org/dagu-win32-arm64',
-  'linux-ppc64': '@dagu-org/dagu-linux-ppc64',
-  'linux-s390x': '@dagu-org/dagu-linux-s390x',
-  'freebsd-arm64': '@dagu-org/dagu-freebsd-arm64',
-  'freebsd-ia32': '@dagu-org/dagu-freebsd-ia32',
-  'freebsd-arm': '@dagu-org/dagu-freebsd-arm',
-  'openbsd-x64': '@dagu-org/dagu-openbsd-x64',
-  'openbsd-arm64': '@dagu-org/dagu-openbsd-arm64',
+  "win32-arm64": "dagu-win32-arm64",
+  "linux-ppc64": "dagu-linux-ppc64",
+  "linux-s390x": "dagu-linux-s390x",
+  "freebsd-arm64": "dagu-freebsd-arm64",
+  "freebsd-ia32": "dagu-freebsd-ia32",
+  "freebsd-arm": "dagu-freebsd-arm",
+  "openbsd-x64": "dagu-openbsd-x64",
+  "openbsd-arm64": "dagu-openbsd-arm64",
 };
 
 // Cache for binary path
@@ -36,37 +35,45 @@ let cachedBinaryPath = null;
  */
 function getArmVariant() {
   // First try process.config
-  if (process.config && process.config.variables && process.config.variables.arm_version) {
+  if (
+    process.config &&
+    process.config.variables &&
+    process.config.variables.arm_version
+  ) {
     return String(process.config.variables.arm_version);
   }
-  
+
   // On Linux, check /proc/cpuinfo
-  if (process.platform === 'linux') {
+  if (process.platform === "linux") {
     try {
-      const cpuinfo = fs.readFileSync('/proc/cpuinfo', 'utf8');
-      
+      const cpuinfo = fs.readFileSync("/proc/cpuinfo", "utf8");
+
       // Check for specific ARM architecture indicators
-      if (cpuinfo.includes('ARMv6') || cpuinfo.includes('ARM926') || cpuinfo.includes('ARM1176')) {
-        return '6';
+      if (
+        cpuinfo.includes("ARMv6") ||
+        cpuinfo.includes("ARM926") ||
+        cpuinfo.includes("ARM1176")
+      ) {
+        return "6";
       }
-      if (cpuinfo.includes('ARMv7') || cpuinfo.includes('Cortex-A')) {
-        return '7';
+      if (cpuinfo.includes("ARMv7") || cpuinfo.includes("Cortex-A")) {
+        return "7";
       }
-      
+
       // Check CPU architecture field
       const archMatch = cpuinfo.match(/^CPU architecture:\s*(\d+)/m);
       if (archMatch && archMatch[1]) {
         const arch = parseInt(archMatch[1], 10);
-        if (arch >= 7) return '7';
-        if (arch === 6) return '6';
+        if (arch >= 7) return "7";
+        if (arch === 6) return "6";
       }
     } catch (e) {
       // Ignore errors, fall through to default
     }
   }
-  
+
   // Default to ARMv7 (more common)
-  return '7';
+  return "7";
 }
 
 /**
@@ -76,32 +83,17 @@ function getArmVariant() {
 function getPlatformPackage() {
   let platform = process.platform;
   let arch = process.arch;
-  
+
   // Special handling for ARM on Linux
-  if (platform === 'linux' && arch === 'arm') {
+  if (platform === "linux" && arch === "arm") {
     const variant = getArmVariant();
-    return `@dagu-org/dagu-linux-armv${variant}`;
+    return `dagu-linux-armv${variant}`;
   }
-  
+
   const key = `${platform}-${arch}`;
   return PLATFORM_MAP[key] || null;
 }
 
-/**
- * Get supported platforms list for error messages
- * @returns {string} Formatted list of supported platforms
- */
-function getSupportedPlatforms() {
-  const platforms = [
-    'Linux: x64, arm64, arm (v6/v7), ia32, ppc64le, s390x',
-    'macOS: x64 (Intel), arm64 (Apple Silicon)',
-    'Windows: x64, ia32, arm64',
-    'FreeBSD: x64, arm64, ia32, arm',
-    'OpenBSD: x64, arm64'
-  ];
-  return platforms.join('\n  - ');
-}
-
 /**
  * Get the path to the Dagu binary
  * @returns {string|null} Path to binary or null if not found
@@ -111,15 +103,17 @@ function getBinaryPath() {
   if (cachedBinaryPath && fs.existsSync(cachedBinaryPath)) {
     return cachedBinaryPath;
   }
-  
-  const binaryName = process.platform === 'win32' ? 'dagu.exe' : 'dagu';
-  
+
+  const binaryName = process.platform === "win32" ? "dagu.exe" : "dagu";
+
   // First, try platform-specific package
   const platformPackage = getPlatformPackage();
   if (platformPackage) {
     try {
       // Try to resolve the binary using require.resolve (Sentry approach)
-      const binaryPath = require.resolve(`${platformPackage}/bin/${binaryName}`);
+      const binaryPath = require.resolve(
+        `${platformPackage}/bin/${binaryName}`
+      );
       if (fs.existsSync(binaryPath)) {
         cachedBinaryPath = binaryPath;
         return binaryPath;
@@ -128,14 +122,14 @@ function getBinaryPath() {
       // Package not installed or binary not found
     }
   }
-  
+
   // Fallback to local binary in main package
-  const localBinary = path.join(__dirname, '..', 'bin', binaryName);
+  const localBinary = path.join(__dirname, "..", "bin", binaryName);
   if (fs.existsSync(localBinary)) {
     cachedBinaryPath = localBinary;
     return localBinary;
   }
-  
+
   return null;
 }
 
@@ -147,24 +141,6 @@ function setPlatformBinary(binaryPath) {
   cachedBinaryPath = binaryPath;
 }
 
-/**
- * Get platform details for debugging
- * @returns {object} Platform information
- */
-function getPlatformInfo() {
-  return {
-    platform: process.platform,
-    arch: process.arch,
-    nodeVersion: process.version,
-    v8Version: process.versions.v8,
-    systemPlatform: os.platform(),
-    systemArch: os.arch(),
-    systemRelease: os.release(),
-    armVariant: process.platform === 'linux' && process.arch === 'arm' ? getArmVariant() : null,
-    detectedPackage: getPlatformPackage()
-  };
-}
-
 /**
  * Check if platform-specific package is installed
  * @returns {boolean} True if installed, false otherwise
@@ -174,9 +150,9 @@ function isPlatformSpecificPackageInstalled() {
   if (!platformPackage) {
     return false;
   }
-  
-  const binaryName = process.platform === 'win32' ? 'dagu.exe' : 'dagu';
-  
+
+  const binaryName = process.platform === "win32" ? "dagu.exe" : "dagu";
+
   try {
     // Resolving will fail if the optionalDependency was not installed
     require.resolve(`${platformPackage}/bin/${binaryName}`);
@@ -186,45 +162,15 @@ function isPlatformSpecificPackageInstalled() {
   }
 }
 
-/**
- * Check if we're in a cross-platform scenario (node_modules moved between architectures)
- * @returns {object|null} Warning info if cross-platform detected
- */
-function checkCrossPlatformScenario() {
-  const pkg = require('../package.json');
-  const optionalDeps = Object.keys(pkg.optionalDependencies || {});
-  const currentPlatformPackage = getPlatformPackage();
-  
-  // Check if any platform package is installed but it's not the right one
-  for (const dep of optionalDeps) {
-    try {
-      require.resolve(`${dep}/package.json`);
-      // Package is installed
-      if (dep !== currentPlatformPackage) {
-        // Wrong platform package is installed
-        const installedPlatform = dep.replace('@dagu-org/dagu-', '');
-        const currentPlatform = `${process.platform}-${process.arch}`;
-        return {
-          installed: installedPlatform,
-          current: currentPlatform,
-          message: `WARNING: Found binary for ${installedPlatform} but current platform is ${currentPlatform}.\nThis usually happens when node_modules are copied between different systems.\nPlease reinstall @dagu-org/dagu to get the correct binary.`
-        };
-      }
-    } catch (e) {
-      // Package not installed, continue checking
-    }
-  }
-  
-  return null;
-}
-
 module.exports = {
   getPlatformPackage,
   getBinaryPath,
   setPlatformBinary,
-  getSupportedPlatforms,
-  getPlatformInfo,
-  getArmVariant,
   isPlatformSpecificPackageInstalled,
-  checkCrossPlatformScenario
-};
+  getPlatformInfo: () => ({
+    platform: process.platform,
+    arch: process.arch,
+    nodeVersion: process.version,
+    detectedPackage: getPlatformPackage(),
+  }),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dagu-org/dagu",
-  "version": "1.17.4",
+  "version": "1.22.10",
   "description": "A powerful Workflow Orchestration Engine with simple declarative YAML API. Zero-dependency, single binary for Linux, macOS, and Windows.",
   "keywords": [
     "workflow",
@@ -25,25 +25,25 @@
   "license": "GPL-3.0",
   "author": "Dagu Contributors",
   "bin": {
-    "dagu": "./bin/dagu"
+    "dagu": "bin/cli"
   },
   "scripts": {
-    "postinstall": "node install.js"
+    "postinstall": "node ./install.js"
   },
   "dependencies": {
-    "tar": "^6.1.15"
+    "tar": "^7.4.3"
   },
   "optionalDependencies": {
-    "@dagu-org/dagu-linux-x64": "1.17.4",
-    "@dagu-org/dagu-linux-arm64": "1.17.4",
-    "@dagu-org/dagu-darwin-x64": "1.17.4",
-    "@dagu-org/dagu-darwin-arm64": "1.17.4",
-    "@dagu-org/dagu-win32-x64": "1.17.4",
-    "@dagu-org/dagu-linux-ia32": "1.17.4",
-    "@dagu-org/dagu-linux-armv7": "1.17.4",
-    "@dagu-org/dagu-linux-armv6": "1.17.4",
-    "@dagu-org/dagu-win32-ia32": "1.17.4",
-    "@dagu-org/dagu-freebsd-x64": "1.17.4"
+    "@dagu-org/dagu-linux-x64": "1.22.10",
+    "@dagu-org/dagu-linux-arm64": "1.22.10",
+    "@dagu-org/dagu-darwin-x64": "1.22.10",
+    "@dagu-org/dagu-darwin-arm64": "1.22.10",
+    "@dagu-org/dagu-win32-x64": "1.22.10",
+    "@dagu-org/dagu-linux-ia32": "1.22.10",
+    "@dagu-org/dagu-linux-armv7": "1.22.10",
+    "@dagu-org/dagu-linux-armv6": "1.22.10",
+    "@dagu-org/dagu-win32-ia32": "1.22.10",
+    "@dagu-org/dagu-freebsd-x64": "1.22.10"
   },
   "engines": {
     "node": ">=14.0.0"

package/lib/cache.js

@@ -1,230 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-const os = require('os');
-
-/**
- * Get cache directory for binaries
- * @returns {string} Cache directory path
- */
-function getCacheDir() {
-  // Use standard cache locations based on platform
-  const homeDir = os.homedir();
-  let cacheDir;
-  
-  if (process.platform === 'win32') {
-    // Windows: %LOCALAPPDATA%\dagu-cache
-    cacheDir = path.join(process.env.LOCALAPPDATA || path.join(homeDir, 'AppData', 'Local'), 'dagu-cache');
-  } else if (process.platform === 'darwin') {
-    // macOS: ~/Library/Caches/dagu
-    cacheDir = path.join(homeDir, 'Library', 'Caches', 'dagu');
-  } else {
-    // Linux/BSD: ~/.cache/dagu
-    cacheDir = path.join(process.env.XDG_CACHE_HOME || path.join(homeDir, '.cache'), 'dagu');
-  }
-  
-  // Allow override via environment variable
-  if (process.env.DAGU_CACHE_DIR) {
-    cacheDir = process.env.DAGU_CACHE_DIR;
-  }
-  
-  return cacheDir;
-}
-
-/**
- * Get cached binary path
- * @param {string} version Version of the binary
- * @param {string} platform Platform identifier
- * @returns {string} Path to cached binary
- */
-function getCachedBinaryPath(version, platform) {
-  const cacheDir = getCacheDir();
-  const binaryName = process.platform === 'win32' ? 'dagu.exe' : 'dagu';
-  return path.join(cacheDir, `${version}-${platform}`, binaryName);
-}
-
-/**
- * Check if binary exists in cache
- * @param {string} version Version of the binary
- * @param {string} platform Platform identifier
- * @returns {boolean} True if cached, false otherwise
- */
-function isCached(version, platform) {
-  const cachedPath = getCachedBinaryPath(version, platform);
-  return fs.existsSync(cachedPath);
-}
-
-/**
- * Save binary to cache
- * @param {string} sourcePath Path to the binary to cache
- * @param {string} version Version of the binary
- * @param {string} platform Platform identifier
- * @returns {string} Path to cached binary
- */
-function cacheBinary(sourcePath, version, platform) {
-  const cachedPath = getCachedBinaryPath(version, platform);
-  const cacheDir = path.dirname(cachedPath);
-  
-  // Create cache directory if it doesn't exist
-  if (!fs.existsSync(cacheDir)) {
-    fs.mkdirSync(cacheDir, { recursive: true });
-  }
-  
-  // Copy binary to cache
-  fs.copyFileSync(sourcePath, cachedPath);
-  
-  // Preserve executable permissions
-  if (process.platform !== 'win32') {
-    fs.chmodSync(cachedPath, 0o755);
-  }
-  
-  // Create a metadata file with cache info
-  const metadataPath = path.join(cacheDir, 'metadata.json');
-  const metadata = {
-    version,
-    platform,
-    cachedAt: new Date().toISOString(),
-    checksum: calculateChecksum(cachedPath)
-  };
-  fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
-  
-  return cachedPath;
-}
-
-/**
- * Get binary from cache
- * @param {string} version Version of the binary
- * @param {string} platform Platform identifier
- * @returns {string|null} Path to cached binary or null if not found
- */
-function getCachedBinary(version, platform) {
-  if (!isCached(version, platform)) {
-    return null;
-  }
-  
-  const cachedPath = getCachedBinaryPath(version, platform);
-  
-  // Verify the cached binary still works
-  try {
-    fs.accessSync(cachedPath, fs.constants.X_OK);
-    return cachedPath;
-  } catch (e) {
-    // Cached binary is corrupted or not executable
-    // Remove it from cache
-    cleanCacheEntry(version, platform);
-    return null;
-  }
-}
-
-/**
- * Calculate checksum of a file
- * @param {string} filePath Path to the file
- * @returns {string} SHA256 checksum
- */
-function calculateChecksum(filePath) {
-  const hash = crypto.createHash('sha256');
-  const data = fs.readFileSync(filePath);
-  hash.update(data);
-  return hash.digest('hex');
-}
-
-/**
- * Clean specific cache entry
- * @param {string} version Version of the binary
- * @param {string} platform Platform identifier
- */
-function cleanCacheEntry(version, platform) {
-  const cacheDir = path.dirname(getCachedBinaryPath(version, platform));
-  
-  if (fs.existsSync(cacheDir)) {
-    fs.rmSync(cacheDir, { recursive: true, force: true });
-  }
-}
-
-/**
- * Clean old cache entries (older than specified days)
- * @param {number} maxAgeDays Maximum age in days (default 30)
- */
-function cleanOldCache(maxAgeDays = 30) {
-  const cacheDir = getCacheDir();
-  
-  if (!fs.existsSync(cacheDir)) {
-    return;
-  }
-  
-  const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
-  const now = Date.now();
-  
-  try {
-    const entries = fs.readdirSync(cacheDir);
-    
-    for (const entry of entries) {
-      const entryPath = path.join(cacheDir, entry);
-      const metadataPath = path.join(entryPath, 'metadata.json');
-      
-      if (fs.existsSync(metadataPath)) {
-        try {
-          const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
-          const cachedAt = new Date(metadata.cachedAt).getTime();
-          
-          if (now - cachedAt > maxAgeMs) {
-            fs.rmSync(entryPath, { recursive: true, force: true });
-          }
-        } catch (e) {
-          // Invalid metadata, remove entry
-          fs.rmSync(entryPath, { recursive: true, force: true });
-        }
-      }
-    }
-  } catch (e) {
-    // Ignore errors during cleanup
-  }
-}
-
-/**
- * Get cache size
- * @returns {number} Total size in bytes
- */
-function getCacheSize() {
-  const cacheDir = getCacheDir();
-  
-  if (!fs.existsSync(cacheDir)) {
-    return 0;
-  }
-  
-  let totalSize = 0;
-  
-  function calculateDirSize(dirPath) {
-    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-    
-    for (const entry of entries) {
-      const fullPath = path.join(dirPath, entry.name);
-      
-      if (entry.isDirectory()) {
-        calculateDirSize(fullPath);
-      } else {
-        const stats = fs.statSync(fullPath);
-        totalSize += stats.size;
-      }
-    }
-  }
-  
-  try {
-    calculateDirSize(cacheDir);
-  } catch (e) {
-    // Ignore errors
-  }
-  
-  return totalSize;
-}
-
-module.exports = {
-  getCacheDir,
-  getCachedBinaryPath,
-  isCached,
-  cacheBinary,
-  getCachedBinary,
-  cleanCacheEntry,
-  cleanOldCache,
-  getCacheSize
-};

package/lib/constants.js

@@ -1,60 +0,0 @@
-/**
- * Constants for Dagu npm distribution
- */
-
-const GITHUB_ORG = 'dagu-org';
-const GITHUB_REPO = 'dagu';
-const NPM_ORG = '@dagu-org';
-
-// Tier classification for platform support
-const PLATFORM_TIERS = {
-  TIER_1: [
-    'linux-x64',
-    'linux-arm64',
-    'darwin-x64',
-    'darwin-arm64',
-    'win32-x64'
-  ],
-  TIER_2: [
-    'linux-ia32',
-    'linux-armv7',
-    'win32-ia32',
-    'freebsd-x64'
-  ],
-  TIER_3: [
-    'linux-armv6',
-    'linux-ppc64',
-    'linux-s390x',
-    'win32-arm64',
-    'freebsd-arm64',
-    'freebsd-ia32',
-    'freebsd-arm',
-    'openbsd-x64',
-    'openbsd-arm64'
-  ]
-};
-
-// Error messages
-const ERRORS = {
-  UNSUPPORTED_PLATFORM: 'Unsupported platform',
-  DOWNLOAD_FAILED: 'Failed to download binary',
-  VALIDATION_FAILED: 'Binary validation failed',
-  CHECKSUM_MISMATCH: 'Checksum verification failed',
-  EXTRACTION_FAILED: 'Failed to extract archive'
-};
-
-// URLs
-const URLS = {
-  RELEASES: `https://github.com/${GITHUB_ORG}/${GITHUB_REPO}/releases`,
-  ISSUES: `https://github.com/${GITHUB_ORG}/${GITHUB_REPO}/issues`,
-  BUILD_DOCS: `https://github.com/${GITHUB_ORG}/${GITHUB_REPO}#building-from-source`
-};
-
-module.exports = {
-  GITHUB_ORG,
-  GITHUB_REPO,
-  NPM_ORG,
-  PLATFORM_TIERS,
-  ERRORS,
-  URLS
-};