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

package/lib/shellapi.js

@@ -23,7 +23,7 @@ function getShellAPIConfigDir() {
 }
 
 class ShellApi {
-	constructor() {}
+	constructor() { }
 
 	async init() {
 		// 检查当前 shell 环境上下文是否配置 HTTP_PROXY
@@ -40,15 +40,15 @@ class ShellApi {
 					'lzc_cli.lib.shellapi.init.conf_file_not_exist_warn',
 					`WARN:: 读取不到以下路径中的文件，无法连接客户端自动判读盒子名称和盒子用户，
 
-{{addrFile}} 盒子的连接地址
-{{credFile}} 盒子的连接凭证
+{{ addrFile }} 盒子的连接地址
+{{ credFile }} 盒子的连接凭证
 
 但可使用环境变量指定:
   - BOX_NAME=foo 指定盒子的名称
   - BOX_UID=bar 指定盒子的用户
 
 NOTE：在指定环境变量的模式下，有些接口依旧不能访问，为了更好的开发体验，建议尽量在同主机的环境下启动客户端`,
-					{ addrFile, credFile },
+					{ addrFile, credFile, interpolation: { escapeValue: false } },
 				),
 			);
 			const md = new grpc.Metadata();
@@ -134,7 +134,7 @@ NOTE：在指定环境变量的模式下，有些接口依旧不能访问，为
 		const boxes = await this.boxList();
 		const box = boxes.find((b) => b.box_name === boxname);
 		if (!box) {
-			throw t('lzc_cli.lib.shellapi.set_default_box.box_not_exists_fail', '{{boxname}} 盒子不存在', { boxname });
+			throw t('lzc_cli.lib.shellapi.set_default_box.box_not_exists_fail', '{{ boxname }} 盒子不存在', { boxname });
 		}
 		return new Promise((resolve, reject) => {
 			this.client.modifyBoxConfig({ id: box.id, name: box.box_name, set_as_default_box: true }, this.metadata, function (err) {

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

@@ -30,7 +30,7 @@ export function checkNodejsVersion() {
 	const requiredVersion = pkgInfo.engines.node;
 	if (!semver.satisfies(process.version, requiredVersion)) {
 		logger.error(
-			t('lzc_cli.lib.utils.check_nodejs_version_no_match_tips', `检测到您当前的 nodejs 版本 {{version}} 不匹配，lzc-cli 最低要求 nodejs 版本为 {{requiredVersion}}, 请升级`, {
+			t('lzc_cli.lib.utils.check_nodejs_version_no_match_tips', `检测到您当前的 nodejs 版本 {{ version }} 不匹配，lzc-cli 最低要求 nodejs 版本为 {{ requiredVersion }}, 请升级`, {
 				version: process.version,
 				requiredVersion,
 			}),
@@ -55,19 +55,21 @@ export async function getLatestVersion(controller, pkgName = pkgInfo.name) {
 		const latestVersion = content['tags']['latest'];
 		if (semver.lt(pkgInfo.version, latestVersion)) {
 			logger.warn(
-				t('lzc_cli.lib.utils.get_latest_version_tips', `检测到 {{pkgName}} 最新版本为 {{latestVersion}}，使用 'npm i -g {{pkgName}}@{{latestVersion}}' 升级到最新版本!`, {
+				t('lzc_cli.lib.utils.get_latest_version_tips', `检测到 {{ pkgName }} 最新版本为 {{ latestVersion }}，使用 'npm i -g {{ pkgName }}@{{ latestVersion }}' 升级到最新版本!`, {
 					pkgName,
 					latestVersion,
+					interpolation: { escapeValue: false }
 				}),
 			);
 		} else {
-			logger.debug(t('lzc_cli.lib.utils.get_latest_version_success_tips', `已经在最新版本: {{latestVersion}}`, { latestVersion }));
+			logger.debug(t('lzc_cli.lib.utils.get_latest_version_success_tips', `已经在最新版本: {{ latestVersion }}`, { latestVersion }));
 		}
 	} catch (err) {
 		logger.debug(
-			t('lzc_cli.lib.utils.get_latest_version_fail_tips', `请求 {{url}} 失败, error: {{err}}`, {
+			t('lzc_cli.lib.utils.get_latest_version_fail_tips', `请求 {{ url }} 失败, error: {{ err }}`, {
 				url,
 				err,
+				interpolation: { escapeValue: false }
 			}),
 		);
 	}
@@ -139,9 +141,10 @@ export function ensureDirectoryExists(filePath, isRenameOrClear) {
 		if (err.code === 'ENOENT') {
 			fs.mkdirSync(filePath, { recursive: true });
 		} else {
-			throw t('lzc_cli.lib.utils.ensure_directory_exists_fail', `创建文件夹{{filePath}}错误: {{err}}`, {
+			throw t('lzc_cli.lib.utils.ensure_directory_exists_fail', `创建文件夹{{ filePath }}错误: {{ err }}`, {
 				filePath,
 				err,
+				interpolation: { escapeValue: false }
 			});
 		}
 	}
@@ -361,7 +364,7 @@ export async function md5File(filepath) {
 }
 
 export class Downloader {
-	constructor() {}
+	constructor() { }
 
 	showDownloadingProgress(received, total) {
 		let percentage = ((received * 100) / total).toFixed(2);
@@ -423,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;
@@ -515,7 +520,7 @@ export async function resolveDomain(domain, quiet = false) {
 		}
 	} catch (error) {
 		if (!quiet) {
-			logger.error(t('lzc_cli.lib.utils.resolve_domain_fail_tips', `无法解析域名 {{domain}}: `, { domain }), error);
+			logger.error(t('lzc_cli.lib.utils.resolve_domain_fail_tips', `无法解析域名 {{ domain }}: `, { domain, interpolation: { escapeValue: false } }), error);
 		}
 		throw error;
 	}
@@ -523,7 +528,7 @@ export async function resolveDomain(domain, quiet = false) {
 
 export function unzipSync(zipPath, destPath, entries = []) {
 	if (!isFileExist(zipPath)) {
-		throw t('lzc_cli.lib.utils.unzip_sync_not_exist_fail', `{{zipPath}} 找不到该文件`, { zipPath });
+		throw t('lzc_cli.lib.utils.unzip_sync_not_exist_fail', `{{ zipPath }} 找不到该文件`, { zipPath, interpolation: { escapeValue: false } });
 	}
 
 	// 确保目标目录存在
@@ -536,7 +541,7 @@ export function unzipSync(zipPath, destPath, entries = []) {
 			try {
 				zip.extractEntryTo(entry, destPath, false, true);
 			} catch {
-				logger.debug(t('lzc_cli.lib.utils.unzip_sync_not_exist_file_log', `压缩包中没有找到 {{entry}} 文件`, { entry }));
+				logger.debug(t('lzc_cli.lib.utils.unzip_sync_not_exist_file_log', `压缩包中没有找到 {{ entry }} 文件`, { entry, interpolation: { escapeValue: false } }));
 			}
 		});
 	} else {
@@ -647,12 +652,12 @@ export function checkRsync() {
 				const versionMatch = check.stdout.match(/rsync\s+version\s+(\d+\.\d+\.\d+)/i);
 				if (!versionMatch || compareVersions('3.2.0', versionMatch[1]) < 0) {
 					reject(
-						t('lzc_cli.lib.utils.check_rsync_version_no_match_fail', `当前 rsync 版本为:{{versionMatch}}, 要求 rsync 版本为: 3.2.0+`, {
+						t('lzc_cli.lib.utils.check_rsync_version_no_match_fail', `当前 rsync 版本为:{{ versionMatch }}, 要求 rsync 版本为: 3.2.0+`, {
 							versionMatch: versionMatch[1],
 						}),
 					);
 				}
-				logger.debug(t('lzc_cli.lib.utils.check_rsync_version_print_log', `当前 rsync 版本为:{{versionMatch}}`, { versionMatch: versionMatch[1] }));
+				logger.debug(t('lzc_cli.lib.utils.check_rsync_version_print_log', `当前 rsync 版本为:{{ versionMatch }}`, { versionMatch: versionMatch[1] }));
 			} else {
 				reject(t('lzc_cli.lib.utils.check_rsync_version_fail', '请检查 rsync 安装是否正确，指定 rsync --version 错误'));
 			}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@lazycatcloud/lzc-cli",
-  "version": "1.3.13",
+  "version": "2.0.0-pre.0",
   "description": "lazycat cloud developer kit",
   "scripts": {
     "release": "release-it patch",
     "prepublishOnly": "node check-changelog.js",
-    "i18n:parser": "i18next-cli extract -c i18next.config.js && prettier -w ./lib/i18n/locales"
+    "i18n:parser": "i18next-cli extract -c i18next.config.js --sync-all && prettier -w ./lib/i18n/locales"
   },
   "files": [
     "template",
@@ -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",
@@ -61,7 +62,7 @@
   "devDependencies": {
     "@release-it/conventional-changelog": "^10.0.1",
     "@types/command-exists": "^1.2.3",
-    "i18next-cli": "^1.29.4",
+    "i18next-cli": "^1.32.0",
     "prettier": "^3.3.3",
     "release-it": "^19.0.4"
   },

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

package/template/_lpk/todolist-golang.manifest.yml.in

@@ -0,0 +1,16 @@
+name: ${name} # app名称
+package: ${package} # app的唯一标识符
+version: 0.0.1 # app的版本
+description: # app描述
+
+license: https://choosealicense.com/licenses/mit/
+homepage: # 出现bug时候提交反馈的地方
+author: # app author
+
+application:
+  subdomain: ${subdomain} # 默认访问子域名前缀
+  image: embed:app-runtime # 引用 lzc-build.yml 里的 images.app-runtime
+  routes:
+    # exec:// 路由会执行 /app/run.sh，并把请求转发到 3000 端口
+    # 适合「一个容器同时承载前端+后端」的入门场景
+    - /=exec://3000,/app/run.sh

package/template/_lpk/todolist-java.manifest.yml.in

@@ -0,0 +1,15 @@
+name: ${name} # app名称
+package: ${package} # app的唯一标识符
+version: 0.0.1 # app的版本
+description: # app描述
+
+license: https://choosealicense.com/licenses/mit/
+homepage: # 出现bug时候提交反馈的地方
+author: # app author
+
+application:
+  subdomain: ${subdomain} # 默认访问子域名前缀
+  image: embed:app-runtime # 引用 lzc-build.yml 里的 images.app-runtime
+  routes:
+    # exec:// 路由会执行 /app/run.sh，并把请求转发到 8080 端口
+    - /=exec://8080,/app/run.sh

package/template/_lpk/todolist-python.manifest.yml.in

@@ -0,0 +1,15 @@
+name: ${name} # app名称
+package: ${package} # app的唯一标识符
+version: 0.0.1 # app的版本
+description: # app描述
+
+license: https://choosealicense.com/licenses/mit/
+homepage: # 出现bug时候提交反馈的地方
+author: # app author
+
+application:
+  subdomain: ${subdomain} # 默认访问子域名前缀
+  image: embed:app-runtime # 引用 lzc-build.yml 里的 images.app-runtime
+  routes:
+    # exec:// 路由会执行 /app/run.sh，并把请求转发到 3000 端口
+    - /=exec://3000,/app/run.sh