@dagu-org/dagu 1.17.4 → 1.23.0

package/README.md

@@ -2,7 +2,7 @@
 
 > A powerful Workflow Orchestration Engine with simple declarative YAML API
 
-[![npm version](https://img.shields.io/npm/v/@dagu-org/dagu.svg)](https://www.npmjs.com/package/@dagu-org/dagu)
+[![npm version](https://img.shields.io/npm/v/%40dagu-org%2Fdagu.svg)](https://www.npmjs.com/package/@dagu-org/dagu)
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 
 ## Installation
@@ -81,4 +81,4 @@ For detailed documentation, visit: https://github.com/dagu-org/dagu
 
 ## License
 
-GNU General Public License v3.0
+GNU General Public License v3.0

package/bin/cli

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+const path = require("path");
+const childProcess = require("child_process");
+
+const { getPlatformPackage } = require("../lib/platform");
+
+const binaryName = process.platform === "win32" ? "dagu.exe" : "dagu";
+
+function getBinaryPath() {
+  const platformSpecificPackageName = getPlatformPackage();
+
+  try {
+    return require.resolve(`${platformSpecificPackageName}/bin/${binaryName}`);
+  } catch (e) {
+    return path.join(__dirname, "..", binaryName);
+  }
+}
+
+function exitForError(error) {
+  if (error && typeof error.status === "number") {
+    process.exit(error.status);
+  }
+
+  if (error && error.signal) {
+    process.kill(process.pid, error.signal);
+    return;
+  }
+
+  const message = error && typeof error.message === "string" ? error.message : "dagu execution failed";
+  if (message) {
+    process.stderr.write(`${message}\n`);
+  }
+
+  process.exit(1);
+}
+
+try {
+  childProcess.execFileSync(getBinaryPath(), process.argv.slice(2), {
+    stdio: "inherit",
+  });
+} catch (error) {
+  exitForError(error);
+}

package/index.js

@@ -1,84 +1,43 @@
-/**
- * Dagu npm package - programmatic interface
- */
+const path = require("path");
+const childProcess = require("child_process");
 
-const { getBinaryPath } = require('./lib/platform');
-const { spawn } = require('child_process');
-const path = require('path');
+const { getPlatformPackage } = require("./lib/platform");
 
-/**
- * Get the path to the Dagu binary
- * @returns {string|null} Path to the binary or null if not found
- */
-function getDaguPath() {
-  return getBinaryPath();
-}
+const binaryName = process.platform === "win32" ? "dagu.exe" : "dagu";
 
-/**
- * Execute Dagu with given arguments
- * @param {string[]} args Command line arguments
- * @param {object} options Child process spawn options
- * @returns {ChildProcess} The spawned child process
- */
-function execute(args = [], options = {}) {
-  const binaryPath = getDaguPath();
-  
-  if (!binaryPath) {
-    throw new Error('Dagu binary not found. Please ensure Dagu is properly installed.');
+function getBinaryPath() {
+  try {
+    const platformSpecificPackageName = getPlatformPackage();
+    return require.resolve(`${platformSpecificPackageName}/bin/${binaryName}`);
+  } catch (e) {
+    return path.join(__dirname, "..", binaryName);
   }
-  
-  return spawn(binaryPath, args, {
-    stdio: 'inherit',
-    ...options
-  });
 }
 
-/**
- * Execute Dagu and return a promise
- * @param {string[]} args Command line arguments
- * @param {object} options Child process spawn options
- * @returns {Promise<{code: number, signal: string|null}>} Exit code and signal
- */
-function executeAsync(args = [], options = {}) {
-  return new Promise((resolve, reject) => {
-    const child = execute(args, {
-      stdio: 'pipe',
-      ...options
-    });
-    
-    let stdout = '';
-    let stderr = '';
-    
-    if (child.stdout) {
-      child.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-    }
-    
-    if (child.stderr) {
-      child.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-    }
-    
-    child.on('error', reject);
-    
-    child.on('close', (code, signal) => {
-      resolve({
-        code,
-        signal,
-        stdout,
-        stderr
-      });
-    });
-  });
+function exitForError(error) {
+  if (error && typeof error.status === "number") {
+    process.exit(error.status);
+  }
+
+  if (error && error.signal) {
+    process.kill(process.pid, error.signal);
+    return;
+  }
+
+  const message = error && typeof error.message === "string" ? error.message : "dagu execution failed";
+  if (message) {
+    process.stderr.write(`${message}\n`);
+  }
+
+  process.exit(1);
 }
 
-module.exports = {
-  getDaguPath,
-  execute,
-  executeAsync,
-  // Re-export useful functions
-  getBinaryPath,
-  getPlatformInfo: require('./lib/platform').getPlatformInfo
-};
+module.exports.runBinary = function (...args) {
+  try {
+    childProcess.execFileSync(getBinaryPath(), args, {
+      stdio: "inherit",
+    });
+  } catch (error) {
+    exitForError(error);
+  }
+};

package/install.js

@@ -1,135 +1,109 @@
 #!/usr/bin/env node
 
-const fs = require('fs');
-const path = require('path');
-const { getBinaryPath, getPlatformPackage, setPlatformBinary, getPlatformInfo } = require('./lib/platform');
-const { downloadBinary, downloadBinaryFromNpm } = require('./lib/download');
-const { validateBinary } = require('./lib/validate');
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+const https = require("https");
 
-async function install() {
-  console.log('Installing Dagu...');
-  
-  try {
-    // Check if running in CI or with --ignore-scripts
-    if (process.env.npm_config_ignore_scripts === 'true') {
-      console.log('Skipping postinstall script (--ignore-scripts flag detected)');
-      return;
-    }
-    
-    // Try to resolve platform-specific package
-    const platformPackage = getPlatformPackage();
-    if (!platformPackage) {
-      console.error(`
-Error: Unsupported platform: ${process.platform}-${process.arch}
+const { getPlatformPackage, isPlatformSpecificPackageInstalled } = require("./lib/platform");
 
-Dagu does not provide pre-built binaries for this platform.
-Please build from source: https://github.com/dagu-org/dagu#building-from-source
-      `);
-      process.exit(1);
-    }
-    
-    console.log(`Detected platform: ${process.platform}-${process.arch}`);
-    console.log(`Looking for package: ${platformPackage}`);
-    
-    // Check for cross-platform scenario
-    const { checkCrossPlatformScenario } = require('./lib/platform');
-    const crossPlatformWarning = checkCrossPlatformScenario();
-    if (crossPlatformWarning) {
-      console.warn(`\n${crossPlatformWarning.message}\n`);
-    }
-    
-    // Check if binary already exists from optionalDependency
-    const existingBinary = getBinaryPath();
-    if (existingBinary && fs.existsSync(existingBinary)) {
-      console.log('Using pre-installed binary from optional dependency');
-      
-      // Validate the binary
-      if (await validateBinary(existingBinary)) {
-        console.log('✓ Dagu installation complete!');
-        return;
-      } else {
-        console.warn('Binary validation failed, attempting to download...');
-      }
-    }
-  } catch (e) {
-    console.log('Optional dependency not found, downloading binary...');
-  }
-  
-  // Fallback: Download binary
-  try {
-    const binaryPath = path.join(__dirname, 'bin', process.platform === 'win32' ? 'dagu.exe' : 'dagu');
-    
-    // Create bin directory if it doesn't exist
-    const binDir = path.dirname(binaryPath);
-    if (!fs.existsSync(binDir)) {
-      fs.mkdirSync(binDir, { recursive: true });
-    }
-    
-    // Skip download in development if flag file exists
-    if (fs.existsSync(path.join(__dirname, '.skip-install'))) {
-      console.log('Development mode: skipping binary download (.skip-install file found)');
-      return;
-    }
-    
-    // Download the binary
-    await downloadBinary(binaryPath, { method: 'auto' });
-    
-    // Validate the downloaded binary
-    if (await validateBinary(binaryPath)) {
-      setPlatformBinary(binaryPath);
-      console.log('✓ Dagu installation complete!');
-      
-      // Print warning about optionalDependencies if none were found
-      if (!hasAnyOptionalDependency()) {
-        console.warn(`
-⚠ WARNING: optionalDependencies may be disabled in your environment.
-For better performance and reliability, consider enabling them.
-See: https://docs.npmjs.com/cli/v8/using-npm/config#optional
-`);
-      }
-    } else {
-      throw new Error('Downloaded binary validation failed');
-    }
-  } catch (error) {
-    console.error('Failed to install Dagu:', error.message);
-    console.error(`
-Platform details:
-${JSON.stringify(getPlatformInfo(), null, 2)}
+// Windows binaries end with .exe so we need to special case them.
+const binaryName = process.platform === "win32" ? "dagu.exe" : "dagu";
 
-Please try one of the following:
-1. Install manually from: https://github.com/dagu-org/dagu/releases
-2. Build from source: https://github.com/dagu-org/dagu#building-from-source
-3. Report this issue: https://github.com/dagu-org/dagu/issues
-    `);
-    process.exit(1);
-  }
+// Adjust the version you want to install. You can also make this dynamic.
+const PACKAGE_VERSION = require("./package.json").version;
+
+// Compute the path we want to emit the fallback binary to
+const fallbackBinaryPath = path.join(__dirname, binaryName);
+
+function makeRequest(url) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, (response) => {
+        if (response.statusCode >= 200 && response.statusCode < 300) {
+          const chunks = [];
+          response.on("data", (chunk) => chunks.push(chunk));
+          response.on("end", () => {
+            resolve(Buffer.concat(chunks));
+          });
+        } else if (
+          response.statusCode >= 300 &&
+          response.statusCode < 400 &&
+          response.headers.location
+        ) {
+          // Follow redirects
+          makeRequest(response.headers.location).then(resolve, reject);
+        } else {
+          reject(
+            new Error(
+              `npm responded with status code ${response.statusCode} when downloading the package!`
+            )
+          );
+        }
+      })
+      .on("error", (error) => {
+        reject(error);
+      });
+  });
 }
 
-// Check if any optional dependency is installed
-function hasAnyOptionalDependency() {
-  const pkg = require('./package.json');
-  const optionalDeps = Object.keys(pkg.optionalDependencies || {});
-  
-  for (const dep of optionalDeps) {
-    try {
-      require.resolve(dep);
-      return true;
-    } catch (e) {
-      // Continue checking
+function extractFileFromTarball(tarballBuffer, filepath) {
+  // Tar archives are organized in 512 byte blocks.
+  // Blocks can either be header blocks or data blocks.
+  // Header blocks contain file names of the archive in the first 100 bytes, terminated by a null byte.
+  // The size of a file is contained in bytes 124-135 of a header block and in octal format.
+  // The following blocks will be data blocks containing the file.
+  let offset = 0;
+  while (offset < tarballBuffer.length) {
+    const header = tarballBuffer.subarray(offset, offset + 512);
+    offset += 512;
+
+    const fileName = header.toString("utf-8", 0, 100).replace(/\0.*/g, "");
+    const fileSize = parseInt(
+      header.toString("utf-8", 124, 136).replace(/\0.*/g, ""),
+      8
+    );
+
+    if (fileName === filepath) {
+      return tarballBuffer.subarray(offset, offset + fileSize);
     }
+
+    // Clamp offset to the uppoer multiple of 512
+    offset = (offset + fileSize + 511) & ~511;
   }
-  
-  return false;
 }
 
-// Handle errors gracefully
-process.on('unhandledRejection', (error) => {
-  console.error('Installation error:', error);
-  process.exit(1);
-});
+async function downloadBinaryFromNpm() {
+  console.log({
+    getPlatformPackage,
+  });
+  // Determine package name for this platform
+  const platformSpecificPackageName = getPlatformPackage();
+
+  const url = `https://registry.npmjs.org/@dagu-org/${platformSpecificPackageName}/-/${platformSpecificPackageName}-${PACKAGE_VERSION}.tgz`;
+  console.log(`Downloading binary distribution package from ${url}...`);
+  // Download the tarball of the right binary distribution package
+  const tarballDownloadBuffer = await makeRequest(url);
+  const tarballBuffer = zlib.unzipSync(tarballDownloadBuffer);
 
-// Run installation
-install().catch((error) => {
-  console.error('Installation failed:', error);
-  process.exit(1);
-});
+  console.log(fallbackBinaryPath);
+
+  // Extract binary from package and write to disk
+  fs.writeFileSync(
+    fallbackBinaryPath,
+    extractFileFromTarball(tarballBuffer, `package/bin/${binaryName}`),
+    { mode: 0o755 } // Make binary file executable
+  );
+}
+
+// Skip downloading the binary if it was already installed via optionalDependencies
+if (!isPlatformSpecificPackageInstalled()) {
+  console.log(
+    "Platform specific package not found. Will manually download binary."
+  );
+  downloadBinaryFromNpm();
+} else {
+  console.log(
+    "Platform specific package already installed. Will fall back to manually downloading binary."
+  );
+}