@dagucloud/dagu 2.6.4

package/README.md

@@ -0,0 +1,84 @@
+# @dagucloud/dagu
+
+> A powerful Workflow Orchestration Engine with simple declarative YAML API
+
+[![npm version](https://img.shields.io/npm/v/%40dagucloud%2Fdagu.svg)](https://www.npmjs.com/package/@dagucloud/dagu)
+[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+
+## Installation
+
+```bash
+npm install -g @dagucloud/dagu
+```
+
+Or add to your project:
+
+```bash
+npm install @dagucloud/dagu
+```
+
+## Usage
+
+### Command Line
+
+After installation, the `dagu` command will be available:
+
+```bash
+# Start the web UI and scheduler
+dagu start-all
+
+# Run a workflow
+dagu start my-workflow.yaml
+
+# Check workflow status
+dagu status my-workflow.yaml
+```
+
+### Programmatic Usage
+
+```javascript
+const { execute, getDaguPath } = require('@dagucloud/dagu');
+
+// Get path to the binary
+const daguPath = getDaguPath();
+
+// Execute dagu commands
+const child = execute(['start', 'workflow.yaml']);
+
+// Or use async/await
+const { executeAsync } = require('@dagucloud/dagu');
+
+async function runWorkflow() {
+  const result = await executeAsync(['start', 'workflow.yaml']);
+  console.log('Exit code:', result.code);
+  console.log('Output:', result.stdout);
+}
+```
+
+## Supported Platforms
+
+This package provides pre-built binaries for:
+
+- **Linux**: x64, arm64, arm (v6/v7), ia32, ppc64le, s390x
+- **macOS**: x64 (Intel), arm64 (Apple Silicon)  
+- **Windows**: x64, ia32, arm64
+- **FreeBSD**: x64, arm64
+- **OpenBSD**: x64, arm64
+
+If your platform is not supported, please build from source: https://github.com/dagucloud/dagu#building-from-source
+
+## Features
+
+- **Zero Dependencies** - Single binary, no runtime requirements
+- **Declarative YAML** - Define workflows in simple YAML format
+- **Web UI** - Beautiful dashboard for monitoring and management
+- **Powerful Scheduling** - Cron expressions, dependencies, and complex workflows
+- **Language Agnostic** - Run any command, script, or executable
+
+## Documentation
+
+For detailed documentation, visit: https://github.com/dagucloud/dagu
+
+## License
+
+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(`@dagucloud/${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

@@ -0,0 +1,48 @@
+/**
+ * Copyright (C) 2026 Yota Hamada
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+const path = require("path");
+const childProcess = require("child_process");
+
+const { getPlatformPackage } = require("./lib/platform");
+
+const binaryName = process.platform === "win32" ? "dagu.exe" : "dagu";
+
+function getBinaryPath() {
+  try {
+    const platformSpecificPackageName = getPlatformPackage();
+    return require.resolve(`@dagucloud/${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);
+}
+
+module.exports.runBinary = function (...args) {
+  try {
+    childProcess.execFileSync(getBinaryPath(), args, {
+      stdio: "inherit",
+    });
+  } catch (error) {
+    exitForError(error);
+  }
+};

package/install.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/**
+ * Copyright (C) 2026 Yota Hamada
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+const https = require("https");
+
+const { getPlatformPackage, isPlatformSpecificPackageInstalled } = require("./lib/platform");
+
+// Windows binaries end with .exe so we need to special case them.
+const binaryName = process.platform === "win32" ? "dagu.exe" : "dagu";
+
+// 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);
+      });
+  });
+}
+
+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;
+  }
+}
+
+async function downloadBinaryFromNpm() {
+  console.log({
+    getPlatformPackage,
+  });
+  // Determine package name for this platform
+  const platformSpecificPackageName = getPlatformPackage();
+  if (!platformSpecificPackageName) {
+    throw new Error(`Unsupported platform: ${process.platform}/${process.arch}`);
+  }
+
+  const url = `https://registry.npmjs.org/@dagucloud/${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);
+
+  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. Skipping manual binary download."
+  );
+}

package/lib/platform.js

@@ -0,0 +1,179 @@
+/**
+ * Copyright (C) 2026 Yota Hamada
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+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-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-linux-ia32",
+  "win32-ia32": "dagu-win32-ia32",
+  "freebsd-x64": "dagu-freebsd-x64",
+
+  // Tier 3 - Rare platforms
+  "win32-arm64": "dagu-win32-arm64",
+  "linux-ppc64": "dagu-linux-ppc64",
+  "linux-s390x": "dagu-linux-s390x",
+  "freebsd-arm64": "dagu-freebsd-arm64",
+  "openbsd-x64": "dagu-openbsd-x64",
+  "openbsd-arm64": "dagu-openbsd-arm64",
+};
+
+// Cache for binary path
+let cachedBinaryPath = null;
+
+/**
+ * Detect ARM variant on Linux systems
+ * @returns {string} ARM variant ('6' or '7')
+ */
+function getArmVariant() {
+  // First try process.config
+  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") {
+    try {
+      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("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";
+      }
+    } catch (e) {
+      // Ignore errors, fall through to default
+    }
+  }
+
+  // Default to ARMv7 (more common)
+  return "7";
+}
+
+/**
+ * Get the npm package name for the current platform
+ * @returns {string|null} Package name or null if unsupported
+ */
+function getPlatformPackage() {
+  let platform = process.platform;
+  let arch = process.arch;
+
+  // Special handling for ARM on Linux
+  if (platform === "linux" && arch === "arm") {
+    const variant = getArmVariant();
+    return `dagu-linux-armv${variant}`;
+  }
+
+  const key = `${platform}-${arch}`;
+  return PLATFORM_MAP[key] || null;
+}
+
+/**
+ * Get the path to the Dagu binary
+ * @returns {string|null} Path to binary or null if not found
+ */
+function getBinaryPath() {
+  // Return cached path if available
+  if (cachedBinaryPath && fs.existsSync(cachedBinaryPath)) {
+    return cachedBinaryPath;
+  }
+
+  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(
+        `@dagucloud/${platformPackage}/bin/${binaryName}`
+      );
+      if (fs.existsSync(binaryPath)) {
+        cachedBinaryPath = binaryPath;
+        return binaryPath;
+      }
+    } catch (e) {
+      // Package not installed or binary not found
+    }
+  }
+
+  // Fallback to local binary in main package
+  const localBinary = path.join(__dirname, "..", binaryName);
+  if (fs.existsSync(localBinary)) {
+    cachedBinaryPath = localBinary;
+    return localBinary;
+  }
+
+  return null;
+}
+
+/**
+ * Set the cached binary path
+ * @param {string} binaryPath Path to the binary
+ */
+function setPlatformBinary(binaryPath) {
+  cachedBinaryPath = binaryPath;
+}
+
+/**
+ * Check if platform-specific package is installed
+ * @returns {boolean} True if installed, false otherwise
+ */
+function isPlatformSpecificPackageInstalled() {
+  const platformPackage = getPlatformPackage();
+  if (!platformPackage) {
+    return false;
+  }
+
+  const binaryName = process.platform === "win32" ? "dagu.exe" : "dagu";
+
+  try {
+    // Resolving will fail if the optionalDependency was not installed
+    require.resolve(`@dagucloud/${platformPackage}/bin/${binaryName}`);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+module.exports = {
+  getPlatformPackage,
+  getBinaryPath,
+  setPlatformBinary,
+  isPlatformSpecificPackageInstalled,
+  getPlatformInfo: () => ({
+    platform: process.platform,
+    arch: process.arch,
+    nodeVersion: process.version,
+    detectedPackage: getPlatformPackage(),
+  }),
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@dagucloud/dagu",
+  "version": "2.6.4",
+  "description": "A powerful Workflow Orchestration Engine with simple declarative YAML API. Zero-dependency, single binary for Linux, macOS, and Windows.",
+  "keywords": [
+    "workflow",
+    "automation",
+    "orchestration",
+    "dag",
+    "pipeline",
+    "scheduler",
+    "task-runner",
+    "workflow-engine",
+    "devops",
+    "ci-cd"
+  ],
+  "homepage": "https://github.com/dagucloud/dagu",
+  "bugs": {
+    "url": "https://github.com/dagucloud/dagu/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dagucloud/dagu.git"
+  },
+  "license": "GPL-3.0",
+  "author": "Dagu Contributors",
+  "bin": {
+    "dagu": "bin/cli"
+  },
+  "scripts": {
+    "postinstall": "node ./install.js"
+  },
+  "dependencies": {
+    "tar": "^7.4.3"
+  },
+  "optionalDependencies": {
+    "@dagucloud/dagu-darwin-arm64": "2.6.4",
+    "@dagucloud/dagu-darwin-x64": "2.6.4",
+    "@dagucloud/dagu-freebsd-arm64": "2.6.4",
+    "@dagucloud/dagu-freebsd-x64": "2.6.4",
+    "@dagucloud/dagu-linux-arm64": "2.6.4",
+    "@dagucloud/dagu-linux-armv6": "2.6.4",
+    "@dagucloud/dagu-linux-armv7": "2.6.4",
+    "@dagucloud/dagu-linux-ia32": "2.6.4",
+    "@dagucloud/dagu-linux-ppc64": "2.6.4",
+    "@dagucloud/dagu-linux-s390x": "2.6.4",
+    "@dagucloud/dagu-linux-x64": "2.6.4",
+    "@dagucloud/dagu-openbsd-arm64": "2.6.4",
+    "@dagucloud/dagu-openbsd-x64": "2.6.4",
+    "@dagucloud/dagu-win32-arm64": "2.6.4",
+    "@dagucloud/dagu-win32-ia32": "2.6.4",
+    "@dagucloud/dagu-win32-x64": "2.6.4"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "install.js",
+    "index.js",
+    "README.md",
+    "LICENSE"
+  ]
+}