@lazycatcloud/lzc-cli 1.3.13 → 2.0.0-pre.0

package/lib/lpk/core.js

@@ -0,0 +1,487 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import archiver from 'archiver';
+import AdmZip from 'adm-zip';
+import * as tar from 'tar';
+import yaml from 'js-yaml';
+import logger from 'loglevel';
+import shellApi from '../shellapi.js';
+import { DebugBridge } from '../debug_bridge.js';
+import { resolveBuildRemoteFromFile } from '../build_remote.js';
+
+function toPosixPath(filePath) {
+	return filePath.split(path.sep).join('/');
+}
+
+export function formatBytes(bytes) {
+	const value = Number(bytes ?? 0);
+	if (!Number.isFinite(value) || value <= 0) {
+		return '0 B';
+	}
+	const units = ['B', 'KiB', 'MiB', 'GiB', 'TiB'];
+	let size = value;
+	let unitIndex = 0;
+	while (size >= 1024 && unitIndex < units.length - 1) {
+		size /= 1024;
+		unitIndex += 1;
+	}
+	const digits = unitIndex === 0 ? 0 : 2;
+	return `${size.toFixed(digits)} ${units[unitIndex]}`;
+}
+
+function normalizeDigest(raw) {
+	const value = String(raw ?? '').trim().toLowerCase();
+	if (!value.startsWith('sha256:')) {
+		return '';
+	}
+	const hexPart = value.slice('sha256:'.length);
+	if (!/^[0-9a-f]{64}$/.test(hexPart)) {
+		return '';
+	}
+	return `sha256:${hexPart}`;
+}
+
+function digestToBlobPath(blobsDir, digest) {
+	const normalized = normalizeDigest(digest);
+	if (!normalized) {
+		throw new Error(`Invalid digest: ${digest}`);
+	}
+	return path.join(blobsDir, normalized.slice('sha256:'.length));
+}
+
+function detectPackageFormat(pkgPath) {
+	const ext = path.basename(pkgPath).toLowerCase();
+	if (ext.endsWith('.lpk.tar') || ext.endsWith('.tar')) {
+		return 'tar';
+	}
+	const fd = fs.openSync(pkgPath, 'r');
+	try {
+		const header = Buffer.alloc(4);
+		fs.readSync(fd, header, 0, 4, 0);
+		if (header[0] === 0x50 && header[1] === 0x4b) {
+			return 'zip';
+		}
+	} finally {
+		fs.closeSync(fd);
+	}
+	return 'tar';
+}
+
+async function extractPackage(pkgPath, format, destDir) {
+	if (format === 'zip') {
+		const zip = new AdmZip(pkgPath);
+		zip.extractAllTo(destDir, true);
+		return;
+	}
+	await tar.x({
+		file: pkgPath,
+		cwd: destDir,
+	});
+}
+
+async function packAsZip(srcDir, outPath) {
+	return new Promise((resolve, reject) => {
+		const output = fs.createWriteStream(outPath);
+		const archive = archiver('zip');
+		archive.on('error', reject);
+		output.on('error', reject);
+		output.on('close', resolve);
+		archive.pipe(output);
+		archive.directory(srcDir, false);
+		archive.finalize();
+	});
+}
+
+async function packAsTar(srcDir, outPath) {
+	const entries = fs.readdirSync(srcDir).sort();
+	await tar.c(
+		{
+			cwd: srcDir,
+			file: outPath,
+			portable: true,
+		},
+		entries,
+	);
+}
+
+async function packPackage(srcDir, format, outPath) {
+	if (format === 'zip') {
+		return packAsZip(srcDir, outPath);
+	}
+	return packAsTar(srcDir, outPath);
+}
+
+function walkFilesRecursive(dir, baseDir = dir) {
+	const result = [];
+	if (!fs.existsSync(dir)) {
+		return result;
+	}
+	for (const entry of fs.readdirSync(dir)) {
+		const absPath = path.join(dir, entry);
+		const stat = fs.statSync(absPath);
+		if (stat.isDirectory()) {
+			result.push(...walkFilesRecursive(absPath, baseDir));
+			continue;
+		}
+		if (stat.isFile()) {
+			result.push(toPosixPath(path.relative(baseDir, absPath)));
+		}
+	}
+	return result;
+}
+
+async function sha256File(filePath) {
+	return new Promise((resolve, reject) => {
+		const hash = crypto.createHash('sha256');
+		let size = 0;
+		const stream = fs.createReadStream(filePath);
+		stream.on('data', (chunk) => {
+			size += chunk.length;
+			hash.update(chunk);
+		});
+		stream.on('error', reject);
+		stream.on('end', () => {
+			resolve({
+				digest: hash.digest('hex'),
+				size,
+			});
+		});
+	});
+}
+
+function readYamlFile(filePath) {
+	if (!fs.existsSync(filePath)) {
+		return {};
+	}
+	return yaml.load(fs.readFileSync(filePath, 'utf-8')) ?? {};
+}
+
+function isSignedPackage(workDir) {
+	const releaseLock = path.join(workDir, 'META', 'release.lock');
+	const sigDir = path.join(workDir, 'META', 'signatures');
+	if (fs.existsSync(releaseLock)) {
+		return true;
+	}
+	if (!fs.existsSync(sigDir) || !fs.statSync(sigDir).isDirectory()) {
+		return false;
+	}
+	return fs.readdirSync(sigDir).some((name) => name.endsWith('.sig'));
+}
+
+function buildAliasInfo(lock, blobsDir) {
+	const lockImages = lock?.images ?? {};
+	const aliases = Object.keys(lockImages).sort();
+
+	const allEmbeddedDigests = new Set();
+	const aliasDetails = [];
+	for (const alias of aliases) {
+		const imageInfo = lockImages[alias] ?? {};
+		const layers = Array.isArray(imageInfo.layers) ? imageInfo.layers : [];
+
+		let embedLayerCount = 0;
+		let upstreamLayerCount = 0;
+		let embedSize = 0;
+		let missingEmbedLayerCount = 0;
+		const uniqueEmbedDigests = new Set();
+
+		for (const layer of layers) {
+			const digest = normalizeDigest(layer?.digest ?? '');
+			if (!digest) {
+				continue;
+			}
+			const source = String(layer?.source ?? '').trim().toLowerCase();
+			if (source === 'embed') {
+				embedLayerCount += 1;
+				uniqueEmbedDigests.add(digest);
+				allEmbeddedDigests.add(digest);
+				const blobPath = digestToBlobPath(blobsDir, digest);
+				if (fs.existsSync(blobPath)) {
+					embedSize += fs.statSync(blobPath).size;
+				} else {
+					missingEmbedLayerCount += 1;
+				}
+			} else {
+				upstreamLayerCount += 1;
+			}
+		}
+
+		aliasDetails.push({
+			alias,
+			imageID: String(imageInfo.image_id ?? ''),
+			upstream: String(imageInfo.upstream ?? ''),
+			embedLayerCount,
+			upstreamLayerCount,
+			embedSize,
+			uniqueEmbedLayerCount: uniqueEmbedDigests.size,
+			missingEmbedLayerCount,
+		});
+	}
+
+	let totalEmbeddedSize = 0;
+	let totalMissingEmbeddedLayerCount = 0;
+	for (const digest of allEmbeddedDigests) {
+		const blobPath = digestToBlobPath(blobsDir, digest);
+		if (fs.existsSync(blobPath)) {
+			totalEmbeddedSize += fs.statSync(blobPath).size;
+		} else {
+			totalMissingEmbeddedLayerCount += 1;
+		}
+	}
+
+	return {
+		aliases,
+		aliasDetails,
+		totalEmbeddedLayerCount: allEmbeddedDigests.size,
+		totalEmbeddedSize,
+		totalMissingEmbeddedLayerCount,
+	};
+}
+
+export async function inspectLpkPackage(pkgPath) {
+	const resolvedPkgPath = path.resolve(pkgPath);
+	if (!fs.existsSync(resolvedPkgPath)) {
+		throw new Error(`Package not found: ${resolvedPkgPath}`);
+	}
+
+	const format = detectPackageFormat(resolvedPkgPath);
+	const pkgStat = fs.statSync(resolvedPkgPath);
+	const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lzc-cli-lpk-info-'));
+	const workDir = path.join(tempDir, 'work');
+	fs.mkdirSync(workDir, { recursive: true });
+	try {
+		await extractPackage(resolvedPkgPath, format, workDir);
+
+		const manifest = readYamlFile(path.join(workDir, 'manifest.yml'));
+		const imagesDir = path.join(workDir, 'images');
+		const imagesLockPath = path.join(workDir, 'images.lock');
+		const hasImagesDir = fs.existsSync(imagesDir) && fs.statSync(imagesDir).isDirectory();
+		const hasImagesLock = fs.existsSync(imagesLockPath);
+		const lpkVersion = hasImagesDir ? 'v2' : 'v1';
+
+		let imageInfo = {
+			aliases: [],
+			aliasDetails: [],
+			totalEmbeddedLayerCount: 0,
+			totalEmbeddedSize: 0,
+			totalMissingEmbeddedLayerCount: 0,
+		};
+		if (hasImagesLock) {
+			const lock = readYamlFile(imagesLockPath);
+			const blobsDir = path.join(imagesDir, 'blobs', 'sha256');
+			imageInfo = buildAliasInfo(lock, blobsDir);
+		}
+
+		return {
+			path: resolvedPkgPath,
+			size: pkgStat.size,
+			format,
+			lpkVersion,
+			signed: isSignedPackage(workDir),
+			packageID: String(manifest?.package ?? ''),
+			appVersion: String(manifest?.version ?? ''),
+			hasImagesDir,
+			hasImagesLock,
+			imageInfo,
+		};
+	} finally {
+		fs.rmSync(tempDir, { recursive: true, force: true });
+	}
+}
+
+async function ensureBridge(baseDir) {
+	const buildRemote = resolveBuildRemoteFromFile(baseDir);
+	if (!buildRemote) {
+		await shellApi.init();
+	}
+	const bridge = new DebugBridge(baseDir, buildRemote);
+	await bridge.init();
+	return bridge;
+}
+
+async function fillMissingDigestsFromUpstream(bridge, upstreamImage, digestSet, blobsDir, tempRoot) {
+	if (!upstreamImage) {
+		throw new Error('Upstream image is required for filling missing blobs');
+	}
+	const pending = new Set([...digestSet].filter((digest) => !fs.existsSync(digestToBlobPath(blobsDir, digest))));
+	if (pending.size === 0) {
+		return { addedCount: 0, addedBytes: 0 };
+	}
+
+	await bridge.lzcDockerPull(upstreamImage);
+	const archivePath = path.join(tempRoot, `upstream-${Date.now()}-${Math.random().toString(16).slice(2)}.tar`);
+	await bridge.lzcDockerSave([upstreamImage], archivePath);
+
+	let addedCount = 0;
+	let addedBytes = 0;
+	const extractDir = fs.mkdtempSync(path.join(tempRoot, 'upstream-extract-'));
+	try {
+		await tar.x({
+			file: archivePath,
+			cwd: extractDir,
+		});
+
+		for (const digest of [...pending]) {
+			const hex = digest.slice('sha256:'.length);
+			const blobSourcePath = path.join(extractDir, 'blobs', 'sha256', hex);
+			if (!fs.existsSync(blobSourcePath)) {
+				continue;
+			}
+			const blobTargetPath = path.join(blobsDir, hex);
+			fs.mkdirSync(path.dirname(blobTargetPath), { recursive: true });
+			if (!fs.existsSync(blobTargetPath)) {
+				fs.copyFileSync(blobSourcePath, blobTargetPath);
+				addedCount += 1;
+				addedBytes += fs.statSync(blobTargetPath).size;
+			}
+			pending.delete(digest);
+		}
+
+		if (pending.size > 0) {
+			const files = walkFilesRecursive(extractDir).filter((relPath) => relPath.endsWith('.tar')).sort();
+			for (const relPath of files) {
+				if (pending.size === 0) {
+					break;
+				}
+				const absPath = path.join(extractDir, relPath);
+				const { digest } = await sha256File(absPath);
+				const fullDigest = `sha256:${digest}`;
+				if (!pending.has(fullDigest)) {
+					continue;
+				}
+				const blobTargetPath = path.join(blobsDir, digest);
+				fs.mkdirSync(path.dirname(blobTargetPath), { recursive: true });
+				if (!fs.existsSync(blobTargetPath)) {
+					fs.copyFileSync(absPath, blobTargetPath);
+					addedCount += 1;
+					addedBytes += fs.statSync(blobTargetPath).size;
+				}
+				pending.delete(fullDigest);
+			}
+		}
+
+		if (pending.size > 0) {
+			throw new Error(`Missing upstream layer blobs after sync: ${[...pending].sort().join(', ')}`);
+		}
+	} finally {
+		fs.rmSync(archivePath, { force: true });
+		fs.rmSync(extractDir, { recursive: true, force: true });
+	}
+
+	return { addedCount, addedBytes };
+}
+
+export async function embedLpkPackage(pkgPath, options = {}) {
+	const resolvedPkgPath = path.resolve(pkgPath);
+	if (!fs.existsSync(resolvedPkgPath)) {
+		throw new Error(`Package not found: ${resolvedPkgPath}`);
+	}
+
+	const format = detectPackageFormat(resolvedPkgPath);
+	const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lzc-cli-lpk-embed-'));
+	const workDir = path.join(tempDir, 'work');
+	const outTemp = path.join(tempDir, format === 'zip' ? 'embedded.lpk' : 'embedded.lpk.tar');
+	fs.mkdirSync(workDir, { recursive: true });
+
+	try {
+		await extractPackage(resolvedPkgPath, format, workDir);
+		const imagesDir = path.join(workDir, 'images');
+		const imagesLockPath = path.join(workDir, 'images.lock');
+		if (!fs.existsSync(imagesDir) || !fs.statSync(imagesDir).isDirectory() || !fs.existsSync(imagesLockPath)) {
+			throw new Error('This package does not contain images.lock/images directory, only lpk v2 is supported');
+		}
+
+		const lock = readYamlFile(imagesLockPath);
+		const lockImages = lock?.images;
+		if (!lockImages || typeof lockImages !== 'object') {
+			throw new Error('Invalid images.lock: images field is missing');
+		}
+		const allAliases = Object.keys(lockImages).sort();
+		if (allAliases.length === 0) {
+			throw new Error('Invalid images.lock: images is empty');
+		}
+
+		const inputAliases = Array.isArray(options.images)
+			? options.images
+					.map((item) => String(item ?? '').trim())
+					.filter((item) => item !== '')
+			: [];
+		const targetAliases = inputAliases.length > 0 ? [...new Set(inputAliases)] : allAliases;
+		for (const alias of targetAliases) {
+			if (!Object.prototype.hasOwnProperty.call(lockImages, alias)) {
+				throw new Error(`Image alias not found in images.lock: ${alias}`);
+			}
+		}
+
+		const blobsDir = path.join(imagesDir, 'blobs', 'sha256');
+		fs.mkdirSync(blobsDir, { recursive: true });
+
+		const missingByUpstream = new Map();
+		let changedLayerCount = 0;
+		for (const alias of targetAliases) {
+			const image = lockImages[alias];
+			const upstream = String(image?.upstream ?? '').trim();
+			const layers = Array.isArray(image?.layers) ? image.layers : [];
+
+			let hasUpstreamLayer = false;
+			for (const layer of layers) {
+				const digest = normalizeDigest(layer?.digest ?? '');
+				if (!digest) {
+					continue;
+				}
+				const source = String(layer?.source ?? '').trim().toLowerCase();
+				if (source === 'embed') {
+					continue;
+				}
+				hasUpstreamLayer = true;
+				changedLayerCount += 1;
+				layer.source = 'embed';
+
+				const blobPath = digestToBlobPath(blobsDir, digest);
+				if (!fs.existsSync(blobPath)) {
+					if (!upstream) {
+						throw new Error(`Alias "${alias}" layer ${digest} requires upstream blob, but upstream is empty`);
+					}
+					if (!missingByUpstream.has(upstream)) {
+						missingByUpstream.set(upstream, new Set());
+					}
+					missingByUpstream.get(upstream).add(digest);
+				}
+			}
+
+			if (hasUpstreamLayer) {
+				image.upstream = '';
+			}
+		}
+
+		let addedBlobCount = 0;
+		let addedBlobBytes = 0;
+		if (missingByUpstream.size > 0) {
+			const bridge = await ensureBridge(process.cwd());
+			for (const [upstream, digestSet] of missingByUpstream.entries()) {
+				logger.info(`Sync upstream blobs from: ${upstream}`);
+				const result = await fillMissingDigestsFromUpstream(bridge, upstream, digestSet, blobsDir, tempDir);
+				addedBlobCount += result.addedCount;
+				addedBlobBytes += result.addedBytes;
+			}
+		}
+
+		fs.writeFileSync(imagesLockPath, yaml.dump(lock, { lineWidth: -1 }));
+		await packPackage(workDir, format, outTemp);
+
+		const finalPath = options.output ? path.resolve(options.output) : resolvedPkgPath;
+		fs.mkdirSync(path.dirname(finalPath), { recursive: true });
+		fs.copyFileSync(outTemp, finalPath);
+
+		return {
+			outputPath: finalPath,
+			targetAliases,
+			changedLayerCount,
+			addedBlobCount,
+			addedBlobBytes,
+		};
+	} finally {
+		fs.rmSync(tempDir, { recursive: true, force: true });
+	}
+}

package/lib/lpk/index.js

@@ -0,0 +1,210 @@
+import logger from 'loglevel';
+import { t } from '../i18n/index.js';
+import { signPackageFile } from '../sig/core.js';
+import { embedLpkPackage, formatBytes, inspectLpkPackage } from './core.js';
+import { resolveBuildRemoteFromFile } from '../build_remote.js';
+import shellApi from '../shellapi.js';
+import { LpkInstaller, installConfig } from '../app/lpk_installer.js';
+import { DebugBridge } from '../debug_bridge.js';
+
+function normalizeErrorMessage(error) {
+	if (!error) {
+		return 'unknown error';
+	}
+	if (typeof error === 'string') {
+		return error;
+	}
+	if (typeof error.message === 'string' && error.message.trim() !== '') {
+		return error.message;
+	}
+	return String(error);
+}
+
+function withErrorHandled(handler) {
+	return async (argv) => {
+		try {
+			await handler(argv);
+		} catch (error) {
+			logger.error(normalizeErrorMessage(error));
+			process.exit(1);
+		}
+	};
+}
+
+function signBuilder(args) {
+	args.option('private-key', {
+		alias: 'k',
+		describe: t('lzc_cli.lib.sig.index.sign_private_key_desc', 'Private key path'),
+		type: 'string',
+	});
+	args.option('public-key', {
+		alias: 'p',
+		describe: t('lzc_cli.lib.sig.index.sign_public_key_desc', 'Public key path'),
+		type: 'string',
+	});
+	args.option('key-id', {
+		describe: t('lzc_cli.lib.sig.index.sign_key_id_desc', 'Signature key id'),
+		type: 'string',
+		default: 'dev',
+	});
+	args.option('o', {
+		alias: 'output',
+		describe: t('lzc_cli.lib.sig.index.sign_output_desc', 'Output package path'),
+		type: 'string',
+	});
+	args.option('resign', {
+		describe: t('lzc_cli.lib.sig.index.sign_resign_desc', 'Force replace existing META signature'),
+		type: 'boolean',
+		default: false,
+	});
+}
+
+async function signHandler({ pkgPath, privateKey, publicKey, keyId, output, resign }) {
+	const out = await signPackageFile(pkgPath, {
+		privateKey,
+		publicKey,
+		keyId,
+		output,
+		resign: !!resign,
+	});
+	logger.info(`${resign ? 're-signed' : 'signed'} package: ${out}`);
+}
+
+async function infoHandler({ pkgPath }) {
+	const info = await inspectLpkPackage(pkgPath);
+
+	logger.info(`path: ${info.path}`);
+	logger.info(`size: ${formatBytes(info.size)} (${info.size} bytes)`);
+	logger.info(`format: ${info.format}`);
+	logger.info(`lpk_version: ${info.lpkVersion}`);
+	logger.info(`signed: ${info.signed ? 'yes' : 'no'}`);
+	logger.info(`package: ${info.packageID || '(unknown)'}`);
+	logger.info(`version: ${info.appVersion || '(unknown)'}`);
+
+	if (!info.hasImagesDir || !info.hasImagesLock) {
+		logger.info('images: none');
+		return;
+	}
+
+	logger.info(`image_count: ${info.imageInfo.aliases.length}`);
+	logger.info(
+		`embedded_layer_size: ${formatBytes(info.imageInfo.totalEmbeddedSize)} (${info.imageInfo.totalEmbeddedSize} bytes, ${info.imageInfo.totalEmbeddedLayerCount} unique layers)`,
+	);
+	if (info.imageInfo.totalMissingEmbeddedLayerCount > 0) {
+		logger.info(`missing_embedded_layers: ${info.imageInfo.totalMissingEmbeddedLayerCount}`);
+	}
+	logger.info('images:');
+	for (const detail of info.imageInfo.aliasDetails) {
+		logger.info(`- alias: ${detail.alias}`);
+		logger.info(`  image_id: ${detail.imageID || '(unknown)'}`);
+		logger.info(`  upstream: ${detail.upstream || '(none)'}`);
+		logger.info(`  embedded_layers: ${detail.embedLayerCount}`);
+		logger.info(`  upstream_layers: ${detail.upstreamLayerCount}`);
+		logger.info(`  embedded_size: ${formatBytes(detail.embedSize)} (${detail.embedSize} bytes)`);
+		if (detail.missingEmbedLayerCount > 0) {
+			logger.info(`  missing_embedded_layers: ${detail.missingEmbedLayerCount}`);
+		}
+	}
+}
+
+async function embedHandler({ pkgPath, output, image }) {
+	const images = Array.isArray(image) ? image : image ? [image] : [];
+	const result = await embedLpkPackage(pkgPath, {
+		output,
+		images,
+	});
+
+	logger.info(`output: ${result.outputPath}`);
+	logger.info(`target_images: ${result.targetAliases.join(', ')}`);
+	logger.info(`converted_layers: ${result.changedLayerCount}`);
+	logger.info(`added_blobs: ${result.addedBlobCount}`);
+	logger.info(`added_blob_size: ${formatBytes(result.addedBlobBytes)} (${result.addedBlobBytes} bytes)`);
+}
+
+async function installHandler({ pkgPath, apk }) {
+	if (!resolveBuildRemoteFromFile(process.cwd())) {
+		await shellApi.init();
+	}
+	installConfig.apk = apk == 'y';
+
+	const installPath = pkgPath ?? process.cwd();
+	const installer = new LpkInstaller();
+	await installer.init();
+	await installer.install(installPath);
+}
+
+async function uninstallHandler({ pkgId, deleteData }) {
+	const buildRemote = resolveBuildRemoteFromFile(process.cwd());
+	if (!buildRemote) {
+		await shellApi.init();
+	}
+
+	const bridge = new DebugBridge(process.cwd(), buildRemote);
+	await bridge.init();
+	await bridge.uninstall(pkgId, deleteData);
+	logger.debug(`default lcmd device: ${bridge.boxname} , uninstall the app ${pkgId} finish`);
+}
+
+export function lpkCommand(program) {
+	const subCommands = [
+		{
+			command: 'info <pkgPath>',
+			desc: 'Show package metadata and embedded image summary',
+			handler: withErrorHandled(infoHandler),
+		},
+		{
+			command: 'embed <pkgPath>',
+			desc: 'Convert selected images to fully embedded mode',
+			builder: (args) => {
+				args.option('image', {
+					describe: 'Target image alias from images.lock, repeatable',
+					type: 'array',
+				});
+				args.option('o', {
+					alias: 'output',
+					describe: 'Output package path, default overwrite input package',
+					type: 'string',
+				});
+			},
+			handler: withErrorHandled(embedHandler),
+		},
+		{
+			command: 'sign <pkgPath>',
+			desc: t('lzc_cli.lib.sig.index.sign_desc', 'Sign lpk package'),
+			builder: signBuilder,
+			handler: withErrorHandled(signHandler),
+		},
+		{
+			command: 'install [pkgPath]',
+			desc: 'Install LPK package to target device',
+			builder: (args) => {
+				args.option('apk', {
+					describe: t('lzc_cli.lib.app.index.lpk_cmd_index_rags_apk_desc', '是否生成APK(y/n)'),
+					type: 'string',
+					default: 'y',
+				});
+			},
+			handler: withErrorHandled(installHandler),
+		},
+		{
+			command: 'uninstall <pkgId>',
+			desc: 'Uninstall package from target device',
+			builder: (args) => {
+				args.option('delete-data', {
+					describe: t('lzc_cli.lib.app.index.lpk_cmd_uninstall_rags_delete_data_desc', '删除应用数据 ⚠️ 警告: 应用数据删除后无法恢复'),
+					type: 'boolean',
+					default: false,
+				});
+			},
+			handler: withErrorHandled(uninstallHandler),
+		},
+	];
+
+	program.command({
+		command: 'lpk',
+		desc: 'LPK package tools',
+		builder: (args) => {
+			args.command(subCommands);
+		},
+	});
+}