@dirigiblelabs/dirigible-cli 14.76.0 → 14.82.0

package/README.md

@@ -22,6 +22,10 @@ workflows.
 There are two primary ways to install and use the Dirigible CLI: globally for system-wide access, or locally as a
 development dependency for project-specific use.
 
+The CLI JAR is not part of the package: the install downloads the `dirigible-cli` executable JAR of the same version from
+Maven Central and verifies its SHA-256 checksum. When the install skips scripts (`--ignore-scripts`, pnpm) or the
+download fails, the first run of `dirigible` downloads it instead.
+
 ### 1. Global Installation (Recommended for CLI Tools)
 
 Install the CLI globally using `npm` to run the `dirigible` command directly from any directory in your terminal.

package/bin/dirigible.js

@@ -1,11 +1,16 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import path from 'node:path';
 import { createRequire } from 'node:module';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const cliJarPath = path.join(__dirname, './dirigible-cli.jar');
+import { ensureCliJar } from '../lib/cli-jar.js';
+
+// downloaded by postinstall.js, or here on the first run when the install skipped it
+let cliJarPath;
+try {
+    cliJarPath = await ensureCliJar();
+} catch (error) {
+    console.error(`❌ ${error.message}`);
+    process.exit(1);
+}
 
 // resolve dirigible jar from package @dirigiblelabs/dirigible
 const require = createRequire(import.meta.url);
@@ -14,7 +19,8 @@ const dirigibleJarPath = require.resolve('@dirigiblelabs/dirigible/data/dirigibl
 const userArgs = process.argv.slice(2);
 
 // Define commands that require the Dirigible jar
-const dirigibleJarCommands = ['start'];
+// (generate runs the platform's own generator from it, #7793)
+const dirigibleJarCommands = ['start', 'generate'];
 
 const userCommand = userArgs[0];
 

package/lib/cli-jar.js

@@ -0,0 +1,101 @@
+// Downloads the CLI jar of this package's version from Maven Central and verifies its SHA-256.
+// The jar is not bundled: since #7708 it carries the intent engine and the templates, and npm
+// refuses a package of its size (#7771).
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import https from 'node:https';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const packageDir = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
+const { version } = JSON.parse(fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8'));
+const dataDir = path.join(packageDir, 'data');
+const versionFile = path.join(dataDir, 'version.txt');
+const url = `https://repo.maven.apache.org/maven2/org/eclipse/dirigible/dirigible-cli/${version}/dirigible-cli-${version}-executable.jar`;
+const MAX_REDIRECTS = 5;
+// some repository hosts and proxies refuse a request without one
+const HEADERS = { 'User-Agent': `dirigible-cli-npm/${version} node/${process.version}` };
+
+export const cliJarPath = path.join(dataDir, 'dirigible-cli-executable.jar');
+
+function isPresent() {
+    return fs.existsSync(cliJarPath) && fs.existsSync(versionFile)
+        && fs.readFileSync(versionFile, 'utf8').trim() === version;
+}
+
+function request(target, redirects = 0) {
+    return new Promise((resolve, reject) => {
+        https.get(target, { headers: HEADERS }, res => {
+            const { statusCode, headers } = res;
+            if (statusCode >= 300 && statusCode < 400 && headers.location) {
+                res.resume();
+                if (redirects >= MAX_REDIRECTS) {
+                    reject(new Error(`Too many redirects downloading ${target}`));
+                    return;
+                }
+                resolve(request(new URL(headers.location, target).toString(), redirects + 1));
+                return;
+            }
+            if (statusCode === 404) {
+                res.resume();
+                // npm publishes at once, Maven Central takes a while to sync a new release
+                reject(new Error(`Dirigible CLI v${version} is not on Maven Central yet (${target}). A new release can take up to 30 minutes to appear - retry in a few minutes.`));
+                return;
+            }
+            if (statusCode !== 200) {
+                res.resume();
+                reject(new Error(`Failed to download ${target}: HTTP ${statusCode}`));
+                return;
+            }
+            resolve(res);
+        }).on('error', error => reject(new Error(`Failed to download ${target}: ${error.message}`)));
+    });
+}
+
+async function readText(target) {
+    const res = await request(target);
+    res.setEncoding('utf8');
+    let text = '';
+    for await (const chunk of res) {
+        text += chunk;
+    }
+    return text;
+}
+
+async function download() {
+    const expected = (await readText(`${url}.sha256`)).trim().split(/\s+/)[0].toLowerCase();
+    console.error(`⬇️ Downloading Dirigible CLI JAR v${version} from URL: ${url}...`);
+    fs.mkdirSync(dataDir, { recursive: true });
+    // Written beside the target and renamed only once verified, so an interrupted or corrupted
+    // download never leaves a jar the launcher would run.
+    const partFile = `${cliJarPath}.part`;
+    const hash = createHash('sha256');
+    try {
+        const res = await request(url);
+        const file = fs.createWriteStream(partFile);
+        await new Promise((resolve, reject) => {
+            res.on('data', chunk => hash.update(chunk));
+            res.on('error', error => reject(new Error(`Download of ${url} interrupted: ${error.message}`)));
+            file.on('error', reject);
+            file.on('finish', resolve);
+            res.pipe(file);
+        });
+        const actual = hash.digest('hex');
+        if (actual !== expected) {
+            throw new Error(`Checksum mismatch for ${url}: expected ${expected}, got ${actual}`);
+        }
+        fs.renameSync(partFile, cliJarPath);
+        fs.writeFileSync(versionFile, version, 'utf8');
+        console.error(`✅ Download complete: ${cliJarPath}`);
+    } finally {
+        fs.rmSync(partFile, { force: true });
+    }
+}
+
+/** Downloads the jar unless the one of this package's version is already in place. */
+export async function ensureCliJar() {
+    if (!isPresent()) {
+        await download();
+    }
+    return cliJarPath;
+}

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@dirigiblelabs/dirigible-cli",
-  "version": "14.76.0",
+  "version": "14.82.0",
   "description": "Eclipse Dirigible CLI",
   "type": "module",
   "scripts": {
+    "postinstall": "node postinstall.js",
     "dirigible": "node ./bin/dirigible.js"
   },
   "bin": {
@@ -14,7 +15,9 @@
     "url": "git+https://github.com/eclipse-dirigible/dirigible.git"
   },
   "files": [
-    "bin"
+    "bin",
+    "lib",
+    "postinstall.js"
   ],
   "keywords": [
     "dirigible-cli",
@@ -28,6 +31,6 @@
   },
   "homepage": "https://github.com/eclipse-dirigible/dirigible#readme",
   "dependencies": {
-    "@dirigiblelabs/dirigible": "14.76.0"
+    "@dirigiblelabs/dirigible": "14.82.0"
   }
 }

package/postinstall.js

@@ -0,0 +1,11 @@
+// Fetches the CLI jar at install time. A failure does not fail the install: the launcher
+// downloads the jar on its first run, which also covers installs that skip install scripts
+// (--ignore-scripts, pnpm) and a release Maven Central has not synced yet.
+import { ensureCliJar } from './lib/cli-jar.js';
+
+try {
+    await ensureCliJar();
+} catch (error) {
+    console.warn(`⚠️ ${error.message}`);
+    console.warn('⚠️ The Dirigible CLI JAR will be downloaded on the first run of "dirigible".');
+}

package/bin/dirigible-cli.jar

@@ -1,4 +0,0 @@
-[diffend] Oversized file quarantined before diffing.
-name: package/bin/dirigible-cli.jar
-size: 36177124 bytes
-sha256: ff2549e50ac164442349451e21fc88eeedb95ed23337e6ce3a5f2933f484973c