@abapify/p2-cli 0.4.0 → 0.4.1

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,6 +1,6 @@
 {
   "name": "@abapify/p2-cli",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/abapify/adt-cli.git",