@abapify/p2-cli 0.0.0 → 0.4.1

package/README.md

@@ -1,3 +1,170 @@
 # @abapify/p2-cli
 
-Placeholder. The real release is published via CI/CD.
+CLI for Eclipse P2 repositories - download, extract, and decompile plugins.
+
+## Installation
+
+```bash
+# npm
+npm install -g @abapify/p2-cli
+
+# or run without installing globally
+npx @abapify/p2-cli --help
+```
+
+## Development
+
+```bash
+# From monorepo root
+bun install
+npx nx build p2-cli
+
+# Or run directly with tsx
+npx tsx tools/p2-cli/src/cli.ts
+```
+
+## Publishing Bootstrap (maintainers)
+
+`p2-cli` is wired into workspace release publishing via `nx release`.
+
+```bash
+# Validate npm publish/trusted-publisher readiness
+bunx nx run p2-cli:npm-trust-check
+
+# One-time bootstrap for new npm package/trusted publishing
+bunx nx run p2-cli:npm-trust-check --prepare
+```
+
+Then publish from CI using the repository release workflow (which triggers `.github/workflows/publish.yml`).
+
+## Commands
+
+### `p2 download <url>`
+
+Download plugins from a P2 repository.
+
+```bash
+# Download ADT plugins from SAP tools
+p2 download https://tools.hana.ondemand.com/latest -o ./sdk
+
+# Filter to specific plugins
+p2 download https://tools.hana.ondemand.com/latest -o ./sdk -f "com.sap.adt.*"
+
+# Download and extract in one step
+p2 download https://tools.hana.ondemand.com/latest -o ./sdk --extract
+```
+
+**Options:**
+
+- `-o, --output <dir>` - Output directory (default: `./p2-download`)
+- `-f, --filter <patterns>` - Filter plugins by ID pattern (comma-separated)
+- `-e, --extract` - Also extract files after download
+- `--extract-output <dir>` - Output directory for extraction
+- `--extract-patterns <patterns>` - File patterns to extract (default: `*.xsd,*.ecore,*.genmodel,*.xml`)
+
+### `p2 extract <input>`
+
+Extract files from JAR archives. Works as a general-purpose JAR extractor.
+
+```bash
+# Extract schemas from downloaded plugins
+p2 extract ./sdk/plugins -o ./extracted
+
+# Extract specific file types
+p2 extract ./sdk/plugins -o ./extracted -p "*.xsd,*.xml"
+
+# Extract everything (no organization)
+p2 extract ./sdk/plugins -o ./extracted -p "*" --no-organize
+
+# Single JAR file
+p2 extract ./my-plugin.jar -o ./extracted
+```
+
+**Options:**
+
+- `-o, --output <dir>` - Output directory (default: `./extracted`)
+- `-p, --patterns <patterns>` - File patterns to extract (default: `*.xsd,*.ecore,*.genmodel,*.xml`)
+- `--no-organize` - Do not organize files by type (flat output)
+- `-v, --verbose` - Verbose output
+
+**Organized output structure:**
+
+```
+extracted/
+├── schemas/
+│   ├── xsd/       # XML Schema definitions
+│   ├── ecore/     # Eclipse EMF models
+│   └── genmodel/  # Generator models
+├── templates/     # Code templates
+├── xml/           # Other XML files
+├── classes/       # Java class files (by JAR)
+└── sources/       # Java source files (by JAR)
+```
+
+### `p2 decompile <input>`
+
+Decompile Java class files to readable source code.
+
+```bash
+# Decompile extracted classes
+p2 decompile ./extracted/classes -o ./decompiled
+
+# Use specific decompiler
+p2 decompile ./extracted/classes -o ./decompiled -d cfr
+```
+
+**Options:**
+
+- `-o, --output <dir>` - Output directory (default: `./decompiled`)
+- `-d, --decompiler <name>` - Decompiler to use (`cfr`, `procyon`, `fernflower`)
+- `-v, --verbose` - Verbose output
+
+**Supported decompilers:**
+
+- **CFR** - `brew install cfr-decompiler` (macOS/Linux)
+- **Procyon** - Download from GitHub
+- **Fernflower** - Bundled with IntelliJ IDEA
+
+## Examples
+
+### Download SAP ADT SDK
+
+```bash
+# Full workflow: download, extract, and organize
+p2 download https://tools.hana.ondemand.com/latest \
+  -o ./adt-sdk \
+  -f "com.sap.adt.*,com.sap.conn.jco.*" \
+  --extract \
+  --extract-output ./adt-sdk/extracted
+
+# Result:
+# ./adt-sdk/
+# ├── artifacts.jar
+# ├── content.jar
+# ├── plugins/
+# │   ├── com.sap.adt.tools.core_3.54.1.jar
+# │   └── ...
+# └── extracted/
+#     ├── schemas/xsd/
+#     ├── schemas/ecore/
+#     └── ...
+```
+
+### Extract from existing Eclipse installation
+
+```bash
+# macOS
+p2 extract /Applications/Eclipse.app/Contents/Eclipse/plugins \
+  -o ./eclipse-schemas \
+  -p "*.xsd"
+
+# Linux
+p2 extract ~/.eclipse/*/plugins -o ./eclipse-schemas
+```
+
+## Requirements
+
+- Node.js 18+
+- `wget` command (for downloads)
+- `unzip` command (for extraction)
+- Java decompiler (optional, for decompilation)

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { Command } from "commander";
+import { existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { basename, join } from "node:path";
+import { execSync } from "node:child_process";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/lib/utils.ts
+/**
+* Execute shell command and return output
+*/
+function execOutput(cmd) {
+	return execSync(cmd, {
+		encoding: "utf-8",
+		maxBuffer: 50 * 1024 * 1024
+	});
+}
+/**
+* Find files matching glob pattern using native find/ls
+*/
+function findFiles(dir, pattern) {
+	if (!existsSync(dir)) return [];
+	const files = [];
+	const entries = readdirSync(dir, {
+		withFileTypes: true,
+		recursive: true
+	});
+	const escaped = pattern.replaceAll(/[.+^${}()|[\]\\/]/g, "\\$&");
+	const regex = new RegExp("^" + escaped.replaceAll(/\*/g, ".*").replaceAll(/\?/g, ".") + "$");
+	for (const entry of entries) if (entry.isFile() && regex.test(entry.name)) {
+		const parentPath = entry.parentPath ?? dir;
+		files.push(join(parentPath, entry.name));
+	}
+	return files;
+}
+/**
+* Ensure directory exists
+*/
+function ensureDir(dir) {
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+//#endregion
+//#region src/commands/download.ts
+/**
+* Parse artifacts.xml from P2 repository
+*/
+function parseArtifacts(xml) {
+	const artifacts = [];
+	const regex = /<artifact classifier='([^']+)' id='([^']+)' version='([^']+)'>/g;
+	let match;
+	while ((match = regex.exec(xml)) !== null) artifacts.push({
+		classifier: match[1],
+		id: match[2],
+		version: match[3]
+	});
+	return artifacts;
+}
+/**
+* Download P2 repository metadata and optionally plugins
+*/
+async function download(repoUrl, options) {
+	const { output, filter, extract, extractOutput, extractPatterns } = options;
+	console.log(`🔧 P2 Repository Download`);
+	console.log(`   Repository: ${repoUrl}`);
+	console.log(`   Output: ${output}`);
+	console.log("");
+	ensureDir(output);
+	const artifactsJar = join(output, "artifacts.jar");
+	console.log("📥 Downloading artifacts.jar...");
+	execOutput(`wget -q "${repoUrl}/artifacts.jar" -O "${artifactsJar}"`);
+	const contentJar = join(output, "content.jar");
+	console.log("📥 Downloading content.jar...");
+	execOutput(`wget -q "${repoUrl}/content.jar" -O "${contentJar}"`);
+	const bundles = parseArtifacts(execOutput(`unzip -p "${artifactsJar}" artifacts.xml`)).filter((a) => a.classifier === "osgi.bundle");
+	console.log(`📋 Found ${bundles.length} plugins`);
+	let toDownload = bundles;
+	if (filter) {
+		const patterns = filter.split(",").map((p) => p.trim());
+		toDownload = bundles.filter((a) => patterns.some((p) => {
+			if (p.includes("*")) {
+				const escaped = p.replaceAll(/[.+?^${}()|[\]\\/]/g, "\\$&");
+				return new RegExp("^" + escaped.replaceAll(/\*/g, ".*") + "$").test(a.id);
+			}
+			return a.id.startsWith(p);
+		}));
+		console.log(`🎯 Filtered to ${toDownload.length} plugins matching: ${filter}`);
+	}
+	if (toDownload.length === 0) {
+		console.log("⚠️  No plugins to download");
+		return;
+	}
+	const pluginsDir = join(output, "plugins");
+	ensureDir(pluginsDir);
+	let downloaded = 0;
+	let skipped = 0;
+	for (let i = 0; i < toDownload.length; i++) {
+		const artifact = toDownload[i];
+		const fileName = `${artifact.id}_${artifact.version}.jar`;
+		const targetPath = join(pluginsDir, fileName);
+		process.stdout.write(`\r   Downloading ${i + 1}/${toDownload.length}: ${artifact.id.slice(0, 50).padEnd(50)}`);
+		if (existsSync(targetPath)) {
+			skipped++;
+			continue;
+		}
+		const url = `${repoUrl}/plugins/${fileName}`;
+		try {
+			execOutput(`wget -q "${url}" -O "${targetPath}"`);
+			downloaded++;
+		} catch {
+			console.error(`\n   ❌ Failed: ${artifact.id}`);
+		}
+	}
+	console.log("\n");
+	console.log("✅ Download complete!");
+	console.log(`   Downloaded: ${downloaded}`);
+	console.log(`   Skipped: ${skipped}`);
+	console.log(`   Location: ${pluginsDir}`);
+	if (extract) {
+		const { extractJars } = await Promise.resolve().then(() => extract_exports);
+		console.log("");
+		await extractJars(pluginsDir, {
+			output: extractOutput || join(output, "extracted"),
+			patterns: extractPatterns
+		});
+	}
+}
+//#endregion
+//#region src/commands/extract.ts
+var extract_exports = /* @__PURE__ */ __exportAll({ extractJars: () => extractJars });
+/**
+* Extract files from JAR archives - just unzip preserving package structure
+*/
+async function extractJars(input, options) {
+	const { output, patterns, verbose = false } = options;
+	console.log(`🔧 JAR Extraction`);
+	console.log(`   Input: ${input}`);
+	console.log(`   Output: ${output}`);
+	console.log(`   Patterns: ${patterns ? patterns.join(", ") : "all files"}`);
+	console.log("");
+	const jars = findFiles(input, "*.jar");
+	if (jars.length === 0) if (input.endsWith(".jar") && existsSync(input)) jars.push(input);
+	else {
+		console.log("❌ No JAR files found");
+		return;
+	}
+	console.log(`📦 Found ${jars.length} JAR files`);
+	console.log("");
+	if (existsSync(output)) rmSync(output, { recursive: true });
+	ensureDir(output);
+	const patternArgs = patterns ? patterns.map((p) => `"${p}"`).join(" ") : "";
+	for (const jar of jars) {
+		const jarName = basename(jar);
+		if (verbose) console.log(`   📦 ${jarName}`);
+		try {
+			execOutput(`unzip -o -q "${jar}" ${patternArgs} -d "${output}" 2>/dev/null || true`);
+		} catch {}
+	}
+	console.log("");
+	console.log("✅ Extraction complete!");
+	console.log(`   Output: ${output}`);
+}
+//#endregion
+//#region src/commands/decompile.ts
+const DECOMPILERS = {
+	cfr: {
+		name: "CFR",
+		check: "which cfr-decompiler",
+		command: (input, output) => `cfr-decompiler "${input}" --outputdir "${output}"`,
+		install: "brew install cfr-decompiler (macOS/Linux) or download from https://www.benf.org/other/cfr/"
+	},
+	procyon: {
+		name: "Procyon",
+		check: "which procyon",
+		command: (input, output) => `procyon -o "${output}" "${input}"`,
+		install: "Download from https://github.com/mstrobel/procyon"
+	},
+	fernflower: {
+		name: "Fernflower",
+		check: "test -f fernflower.jar",
+		command: (input, output) => `java -jar fernflower.jar "${input}" "${output}"`,
+		install: "Find in IntelliJ IDEA: plugins/java-decompiler/lib/java-decompiler.jar"
+	}
+};
+/**
+* Check if a decompiler is available
+*/
+function isDecompilerAvailable(decompiler) {
+	try {
+		execSync(DECOMPILERS[decompiler].check, { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Find available decompiler
+*/
+function findDecompiler() {
+	for (const key of Object.keys(DECOMPILERS)) if (isDecompilerAvailable(key)) return key;
+	return null;
+}
+/**
+* Decompile Java class files or JAR files
+*/
+async function decompile(input, options) {
+	const { output, decompiler: requestedDecompiler, filter, verbose = false } = options;
+	console.log(`🔧 Java Decompilation`);
+	console.log(`   Input: ${input}`);
+	console.log(`   Output: ${output}`);
+	console.log("");
+	const decompiler = requestedDecompiler || findDecompiler();
+	if (!decompiler) {
+		console.log("❌ No Java decompiler found!");
+		console.log("");
+		console.log("Install one of these decompilers:");
+		for (const [_key, config] of Object.entries(DECOMPILERS)) console.log(`   ${config.name}: ${config.install}`);
+		process.exit(1);
+	}
+	if (requestedDecompiler && !isDecompilerAvailable(requestedDecompiler)) {
+		console.log(`❌ Requested decompiler '${requestedDecompiler}' is not available.`);
+		console.log(`   ${DECOMPILERS[requestedDecompiler].install}`);
+		process.exit(1);
+	}
+	const config = DECOMPILERS[decompiler];
+	console.log(`📦 Using decompiler: ${config.name}`);
+	console.log("");
+	ensureDir(output);
+	let jarFiles = findFiles(input, "*.jar");
+	if (filter && jarFiles.length > 0) {
+		const patterns = filter.split(",").map((p) => p.trim());
+		jarFiles = jarFiles.filter((jar) => {
+			const jarName = basename(jar);
+			return patterns.some((pattern) => {
+				const escaped = pattern.replaceAll(/[.+?^${}()|[\]\\/]/g, "\\$&");
+				return new RegExp(escaped.replaceAll(/\*/g, ".*")).test(jarName);
+			});
+		});
+		console.log(`🎯 Filtered to ${jarFiles.length} JARs matching: ${filter}`);
+	}
+	if (jarFiles.length > 0) {
+		console.log(`🔍 Found ${jarFiles.length} JAR files`);
+		console.log("");
+		let success = 0;
+		let failed = 0;
+		for (let i = 0; i < jarFiles.length; i++) {
+			const jar = jarFiles[i];
+			const jarName = basename(jar, ".jar");
+			process.stdout.write(`\r   Decompiling ${i + 1}/${jarFiles.length}: ${jarName.slice(0, 50).padEnd(50)}`);
+			try {
+				execSync(config.command(jar, output), { stdio: "ignore" });
+				success++;
+			} catch {
+				if (verbose) console.error(`\n   ❌ Failed: ${jarName}`);
+				failed++;
+			}
+		}
+		console.log("\n");
+		console.log("✅ Decompilation complete!");
+		console.log(`   Success: ${success}`);
+		console.log(`   Failed: ${failed}`);
+		console.log(`   Output: ${output}`);
+	} else {
+		const classFiles = findFiles(input, "*.class");
+		if (classFiles.length === 0) {
+			console.log("❌ No JAR or class files found");
+			return;
+		}
+		console.log(`🔍 Found ${classFiles.length} class files`);
+		console.log("");
+		let success = 0;
+		let failed = 0;
+		for (let i = 0; i < classFiles.length; i++) {
+			const classFile = classFiles[i];
+			if (verbose) process.stdout.write(`\r   Decompiling ${i + 1}/${classFiles.length}: ${basename(classFile).slice(0, 50).padEnd(50)}`);
+			try {
+				execSync(config.command(classFile, output), { stdio: "ignore" });
+				success++;
+			} catch {
+				failed++;
+			}
+		}
+		console.log("\n");
+		console.log("✅ Decompilation complete!");
+		console.log(`   Success: ${success}`);
+		console.log(`   Failed: ${failed}`);
+		console.log(`   Output: ${output}`);
+	}
+}
+//#endregion
+//#region src/cli.ts
+/**
+* P2 CLI - Eclipse P2 Repository Tools
+*
+* Commands:
+*   p2 download <url>     Download plugins from P2 repository
+*   p2 extract <input>    Extract files from JAR archives
+*   p2 decompile <input>  Decompile Java class files
+*/
+const program = new Command();
+const pkg = createRequire(import.meta.url)("../package.json");
+program.name("p2").description("CLI for Eclipse P2 repositories - download, extract, and decompile plugins").version(pkg.version ?? "0.0.0");
+program.command("download <url>").description("Download plugins from a P2 repository").option("-o, --output <dir>", "Output directory", "./p2-download").option("-f, --filter <patterns>", "Filter plugins by ID pattern (comma-separated)", "").option("-e, --extract", "Also extract files after download").option("--extract-output <dir>", "Output directory for extraction").option("--extract-patterns <patterns>", "File patterns to extract (comma-separated, default: all)").action(async (url, opts) => {
+	await download(url, {
+		output: opts.output,
+		filter: opts.filter || void 0,
+		extract: opts.extract,
+		extractOutput: opts.extractOutput,
+		extractPatterns: opts.extractPatterns?.split(",").map((p) => p.trim())
+	});
+});
+program.command("extract <input>").description("Extract files from JAR archives (preserves package structure)").option("-o, --output <dir>", "Output directory", "./extracted").option("-p, --patterns <patterns>", "File patterns to extract (comma-separated, default: all)").option("-v, --verbose", "Verbose output").action(async (input, opts) => {
+	await extractJars(input, {
+		output: opts.output,
+		patterns: opts.patterns ? opts.patterns.split(",").map((p) => p.trim()) : void 0,
+		verbose: opts.verbose
+	});
+});
+program.command("decompile <input>").description("Decompile Java class files or JAR files").option("-o, --output <dir>", "Output directory", "./decompiled").option("-f, --filter <patterns>", "Filter JARs by name pattern (comma-separated)").option("-d, --decompiler <name>", "Decompiler to use (cfr, procyon, fernflower)").option("-v, --verbose", "Verbose output").action(async (input, opts) => {
+	await decompile(input, {
+		output: opts.output,
+		filter: opts.filter,
+		decompiler: opts.decompiler,
+		verbose: opts.verbose
+	});
+});
+program.parse();
+//#endregion
+export {};

package/package.json

@@ -1,5 +1,39 @@
 {
   "name": "@abapify/p2-cli",
-  "version": "0.0.0",
-  "description": "Placeholder — real package is published via CI/CD (trusted publishing)."
+  "version": "0.4.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abapify/adt-cli.git",
+    "directory": "tools/p2-cli"
+  },
+  "homepage": "https://github.com/abapify/adt-cli/tree/main/tools/p2-cli#readme",
+  "bugs": {
+    "url": "https://github.com/abapify/adt-cli/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "CLI for Eclipse P2 repositories - download, extract, and decompile plugins",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "p2": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "sap",
+    "eclipse",
+    "p2",
+    "cli",
+    "decompiler"
+  ],
+  "dependencies": {
+    "commander": "*"
+  }
 }