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

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);
+		},
+	});
+}

package/lib/sig/core.js

@@ -0,0 +1,254 @@
+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 { t } from '../i18n/index.js';
+
+function toPosixPath(filePath) {
+	return filePath.split(path.sep).join('/');
+}
+
+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 loadManifestInfo(workDir) {
+	const manifestPath = path.join(workDir, 'manifest.yml');
+	if (!fs.existsSync(manifestPath)) {
+		return { appid: '', version: '' };
+	}
+	try {
+		const manifest = yaml.load(fs.readFileSync(manifestPath, 'utf-8'));
+		return {
+			appid: manifest?.package ?? '',
+			version: manifest?.version ? String(manifest.version) : '',
+		};
+	} catch {
+		return { appid: '', version: '' };
+	}
+}
+
+function hasMetaSignData(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((f) => f.endsWith('.sig'));
+}
+
+async function writeMetaSignatureFiles(workDir, privateKeyPath, publicKeyPath, keyId) {
+	const filePaths = walkFilesRecursive(workDir)
+		.filter((p) => !p.startsWith('META/'))
+		.sort();
+	const objects = [];
+	for (const relPath of filePaths) {
+		const absPath = path.join(workDir, relPath);
+		const { digest, size } = await sha256File(absPath);
+		objects.push({
+			path: relPath,
+			digest: `sha256:${digest}`,
+			size,
+		});
+	}
+
+	const manifestInfo = loadManifestInfo(workDir);
+	const releaseLock = {
+		schema: 'lazycat.lpk.release-lock/v1',
+		appid: manifestInfo.appid,
+		version: manifestInfo.version,
+		objects,
+	};
+	const releaseLockContent = Buffer.from(JSON.stringify(releaseLock, null, 2));
+
+	const privateKeyPem = fs.readFileSync(privateKeyPath, 'utf-8');
+	const publicKeyPem = fs.readFileSync(publicKeyPath, 'utf-8');
+	const privateKey = crypto.createPrivateKey(privateKeyPem);
+	const signature = crypto.sign(null, releaseLockContent, privateKey).toString('base64');
+
+	const metaDir = path.join(workDir, 'META');
+	const keyDir = path.join(metaDir, 'keys');
+	const sigDir = path.join(metaDir, 'signatures');
+	fs.mkdirSync(keyDir, { recursive: true });
+	fs.mkdirSync(sigDir, { recursive: true });
+	fs.writeFileSync(path.join(metaDir, 'release.lock'), releaseLockContent);
+	fs.writeFileSync(path.join(keyDir, `${keyId}.pub`), publicKeyPem);
+	fs.writeFileSync(
+		path.join(sigDir, `${keyId}.sig`),
+		JSON.stringify(
+			{
+				schema: 'lazycat.lpk.signature/v1',
+				algorithm: 'ed25519',
+				key_id: keyId,
+				signed_file: 'META/release.lock',
+				signature,
+			},
+			null,
+			2,
+		),
+	);
+}
+
+export async function signPackageFile(pkgPath, options = {}) {
+	const { privateKey, publicKey, keyId = 'dev', output, resign = false } = options;
+
+	if (!pkgPath || !fs.existsSync(pkgPath)) {
+		throw new Error(t('lzc_cli.lib.sig.index.pkg_not_found_fail', `Package not found: ${pkgPath}`));
+	}
+
+	const resolvedPrivateKey = privateKey ? path.resolve(privateKey) : path.resolve('.sig', `${keyId}.ed25519.private.pem`);
+	const resolvedPublicKey = publicKey ? path.resolve(publicKey) : path.resolve('.sig', `${keyId}.ed25519.public.pem`);
+	if (!fs.existsSync(resolvedPrivateKey)) {
+		throw new Error(t('lzc_cli.lib.sig.index.private_key_not_found_fail', `Private key not found: ${resolvedPrivateKey}`));
+	}
+	if (!fs.existsSync(resolvedPublicKey)) {
+		throw new Error(t('lzc_cli.lib.sig.index.public_key_not_found_fail', `Public key not found: ${resolvedPublicKey}`));
+	}
+
+	const format = detectPackageFormat(pkgPath);
+	const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lzc-cli-sign-'));
+	const outTemp = path.join(tempDir, format === 'zip' ? 'signed.lpk' : 'signed.lpk.tar');
+	const workDir = path.join(tempDir, 'work');
+	fs.mkdirSync(workDir, { recursive: true });
+	try {
+		await extractPackage(pkgPath, format, workDir);
+		if (resign) {
+			fs.rmSync(path.join(workDir, 'META'), { recursive: true, force: true });
+		} else if (hasMetaSignData(workDir)) {
+			throw new Error(t('lzc_cli.lib.sig.index.package_already_signed_fail', 'Package already signed, use `lzc-cli lpk sign --resign`'));
+		}
+
+		await writeMetaSignatureFiles(workDir, resolvedPrivateKey, resolvedPublicKey, keyId);
+		await packPackage(workDir, format, outTemp);
+
+		const finalPath = output ? path.resolve(output) : path.resolve(pkgPath);
+		fs.mkdirSync(path.dirname(finalPath), { recursive: true });
+		fs.copyFileSync(outTemp, finalPath);
+		return finalPath;
+	} finally {
+		fs.rmSync(tempDir, { recursive: true, force: true });
+	}
+}
+
+export function generateKeyPair(outputDir, name, force = false) {
+	const targetDir = path.resolve(outputDir || process.cwd());
+	fs.mkdirSync(targetDir, { recursive: true });
+
+	const privateKeyPath = path.join(targetDir, `${name}.ed25519.private.pem`);
+	const publicKeyPath = path.join(targetDir, `${name}.ed25519.public.pem`);
+	if (!force && (fs.existsSync(privateKeyPath) || fs.existsSync(publicKeyPath))) {
+		throw new Error(t('lzc_cli.lib.sig.index.key_exists_fail', `Key files already exist: ${privateKeyPath}, ${publicKeyPath}`));
+	}
+
+	const { privateKey, publicKey } = crypto.generateKeyPairSync('ed25519');
+	const privateKeyPem = privateKey.export({ type: 'pkcs8', format: 'pem' });
+	const publicKeyPem = publicKey.export({ type: 'spki', format: 'pem' });
+
+	fs.writeFileSync(privateKeyPath, privateKeyPem);
+	fs.chmodSync(privateKeyPath, 0o600);
+	fs.writeFileSync(publicKeyPath, publicKeyPem);
+	return { privateKeyPath, publicKeyPath };
+}

package/lib/sig/index.js

@@ -0,0 +1,88 @@
+import logger from 'loglevel';
+import { t } from '../i18n/index.js';
+import { generateKeyPair, signPackageFile } from './core.js';
+
+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}`);
+}
+
+export function sigCommand(program) {
+	const subCommands = [
+		{
+			command: '$0 <pkgPath>',
+			desc: t('lzc_cli.lib.sig.index.sign_desc', 'Sign lpk package'),
+			builder: signBuilder,
+			handler: signHandler,
+		},
+		{
+			command: 'gen-key [outputDir]',
+			desc: t('lzc_cli.lib.sig.index.gen_key_desc', 'Generate developer key pair'),
+			builder: (args) => {
+				args.option('name', {
+					describe: t('lzc_cli.lib.sig.index.gen_key_name_desc', 'Key name'),
+					type: 'string',
+					default: 'dev',
+				});
+				args.option('force', {
+					describe: t('lzc_cli.lib.sig.index.gen_key_force_desc', 'Overwrite existing key files'),
+					type: 'boolean',
+					default: false,
+				});
+			},
+			handler: async ({ outputDir, name, force }) => {
+				const { privateKeyPath, publicKeyPath } = generateKeyPair(outputDir || '.sig', name, force);
+				logger.info(`private key: ${privateKeyPath}`);
+				logger.info(`public key: ${publicKeyPath}`);
+			},
+		},
+		{
+			command: 'sign <pkgPath>',
+			desc: t('lzc_cli.lib.sig.index.sign_desc', 'Sign lpk package'),
+			builder: signBuilder,
+			handler: signHandler,
+		},
+	];
+
+	program.command({
+		command: 'sig',
+		desc: t('lzc_cli.lib.sig.index.sig_cmd_desc', 'LPK signature tools'),
+		builder: (args) => {
+			args.command(subCommands);
+		},
+	});
+}

package/lib/utils.js

@@ -426,12 +426,14 @@ export function isUserApp(manifest) {
 	return !!manifest['application']['user_app'];
 }
 
-export async function tarContentDir(from, to, cwd = './') {
+export async function tarContentDir(from, to, cwd = './', options = {}) {
+	const gzipEnabled = !!options.gzip;
 	return new Promise((resolve, reject) => {
 		const dest = fs.createWriteStream(to);
 		tar.c(
 			{
 				cwd: cwd,
+				gzip: gzipEnabled,
 				filter: (filePath) => {
 					logger.debug(`tar gz ${filePath}`);
 					return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazycatcloud/lzc-cli",
-  "version": "1.3.14",
+  "version": "2.0.0-pre.0",
   "description": "lazycat cloud developer kit",
   "scripts": {
     "release": "release-it patch",
@@ -49,6 +49,7 @@
     "inquirer": "^10.1.8",
     "isbinaryfile": "^5.0.2",
     "js-yaml": "^4.1.0",
+    "lodash": "^4.17.23",
     "lodash.debounce": "^4.0.8",
     "lodash.merge": "^4.6.2",
     "lodash.mergewith": "^4.6.2",

package/scripts/cli.js

@@ -14,6 +14,7 @@ import { appstoreCommand } from '../lib/appstore/index.js';
 import { lpkAppCommand, lpkProjectCommand } from '../lib/app/index.js';
 import { configCommand } from '../lib/config/index.js';
 import { lzcDockerCommand } from '../lib/docker/index.js';
+import { lpkCommand } from '../lib/lpk/index.js';
 
 function setLoggerLevel({ log }) {
 	logger.setLevel(log, false);
@@ -26,6 +27,7 @@ function checkLatestVersion(controller) {
 				case 'project':
 				case 'app':
 				case 'appstore':
+				case 'lpk':
 					getLatestVersion(controller);
 			}
 		}
@@ -63,6 +65,7 @@ lpkAppCommand(program);
 lpkProjectCommand(program);
 appstoreCommand(program);
 lzcDockerCommand(program);
+lpkCommand(program);
 
 // 当没有参数的时候，默认显示帮助。
 (async () => {
@@ -84,6 +87,7 @@ lzcDockerCommand(program);
 				case 'project':
 				case 'appstore':
 				case 'config':
+				case 'lpk':
 					program.showHelp();
 					return;
 			}

package/template/_lpk/README.md

@@ -1,6 +1,13 @@
 
 # 懒猫云应用
 
+## 第一次部署（先看到结果）
+```bash
+npm install
+lzc-cli project deploy
+lzc-cli project info
+```
+
 ## 构建
 ```
 lzc-cli project build -o you-awesome.lpk
@@ -9,12 +16,13 @@ lzc-cli project build -o you-awesome.lpk
 
 ## 安装
 ```
-lzc-cli app install you-awesome.lpk
+lzc-cli lpk install you-awesome.lpk
 ```
 
-## 开发
+## 修改源码后再次部署
 ```
-lzc-cli project devshell -b
+lzc-cli project deploy
+lzc-cli project log -f
 ```
 
 ## 成为懒猫云应用开发者

package/template/_lpk/gui-vnc.manifest.yml.in

@@ -0,0 +1,27 @@
+name: ${name} # app名称
+package: ${package} # app的唯一标识符
+version: 0.0.1 # app的版本
+description: # app描述
+
+license: https://choosealicense.com/licenses/mit/
+homepage: # 项目主页或文档地址
+author: # app author
+
+# application 是默认前台容器，对应固定 service 名 app
+application:
+  subdomain: ${subdomain} # 默认访问子域名前缀
+  routes:
+    # 将入口流量转发到 desktop service 的 6901 端口（VNC Web）
+    - /=http://desktop:6901/
+  # app 在启动时依赖 desktop 就绪
+  depends_on:
+    - desktop
+  # 多实例：每个用户部署自己的实例
+  multi_instance: true
+
+services:
+  desktop:
+    # 使用容器内桌面用户启动
+    user: lazycat:kasm-user
+    # 引用 lzc-build.yml 里的 images.app-runtime
+    image: embed:app-runtime

package/template/_lpk/manifest.yml.in

@@ -7,8 +7,10 @@ license: https://choosealicense.com/licenses/mit/
 homepage: # 出现bug时候提交反馈的地方
 author: # app author
 
-#application作为一个特殊的container运行，对应的service名称为固定的`app`，其他service可以通过此名称与app进行通讯
+# application 作为默认前台容器运行，对应固定 service 名 app
 application:
-  subdomain: ${subdomain} #期望的app域名
+  subdomain: ${subdomain} # 默认访问子域名前缀
   routes:
+    # file:// 路由：直接返回静态文件（前端构建产物）
+    # 该示例默认读取 /lzcapp/pkg/content/dist 下的内容
     - /=file:///lzcapp/pkg/content/dist