@lazycatcloud/lzc-cli 1.3.17 → 2.0.0-pre.1

package/lib/utils.js

@@ -182,28 +182,38 @@ export function loadFromYaml(file) {
 }
 
 // lzc-manifest.yml 要支持模板，目前无法直接用yaml库解释，手动读出必要字段
-export function fakeLoadManifestYml(file) {
-	const res = fs.readFileSync(file, 'utf8');
+function fakeLoadManifestCore(text) {
 	let obj = {
 		application: {
 			subdomain: undefined,
 		},
 	};
 
-	res.split('\n').forEach((v) => {
+	const normalizeValue = (value) => {
+		const commentIndex = value.indexOf(' #');
+		if (commentIndex >= 0) {
+			value = value.slice(0, commentIndex);
+		}
+		return value.trim();
+	};
+
+	String(text ?? '').split('\n').forEach((v) => {
 		let line = v.trim();
 		const arr = line.split(':');
 		if (arr.length != 2) {
 			return;
 		}
 		let [key, value] = arr;
-		value = value.trim();
+		value = normalizeValue(value);
 		if (!obj.package && key == 'package') {
 			obj.package = value;
 		}
 		if (!obj.application.subdomain && key == 'subdomain') {
 			obj.application.subdomain = value;
 		}
+		if (!obj.name && key == 'name') {
+			obj.name = value;
+		}
 		if (!obj.version && key == 'version') {
 			obj.version = value;
 		}
@@ -211,6 +221,14 @@ export function fakeLoadManifestYml(file) {
 	return obj;
 }
 
+export function fakeLoadManifestText(text) {
+	return fakeLoadManifestCore(text);
+}
+
+export function fakeLoadManifestYml(file) {
+	return fakeLoadManifestCore(fs.readFileSync(file, 'utf8'));
+}
+
 export function dumpToYaml(template, target) {
 	fs.writeFileSync(
 		target,
@@ -426,12 +444,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;
@@ -524,16 +544,29 @@ 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, interpolation: { escapeValue: false } });
+function detectLpkArchiveFormatSync(filePath) {
+	const fd = fs.openSync(filePath, 'r');
+	try {
+		const header = Buffer.alloc(512);
+		const bytesRead = fs.readSync(fd, header, 0, header.length, 0);
+		if (bytesRead >= 4 && header[0] === 0x50 && header[1] === 0x4b && header[2] === 0x03 && header[3] === 0x04) {
+			return 'zip';
+		}
+		if (bytesRead >= 265 && header.subarray(257, 262).toString() === 'ustar') {
+			return 'tar';
+		}
+		throw new Error(`Unsupported LPK archive format: ${filePath}`);
+	} finally {
+		fs.closeSync(fd);
 	}
+}
 
-	// 确保目标目录存在
-	fs.mkdirSync(destPath, { recursive: true });
-	// 创建 zip 实例
-	const zip = new AdmZip(zipPath);
+function normalizeArchiveEntryPath(entryPath) {
+	return String(entryPath ?? '').replace(/^\.\//, '').replace(/\\/g, '/');
+}
 
+function extractZipEntriesSync(zipPath, destPath, entries = []) {
+	const zip = new AdmZip(zipPath);
 	if (entries.length > 0) {
 		entries.forEach((entry) => {
 			try {
@@ -542,10 +575,56 @@ export function unzipSync(zipPath, destPath, entries = []) {
 				logger.debug(t('lzc_cli.lib.utils.unzip_sync_not_exist_file_log', `压缩包中没有找到 {{ entry }} 文件`, { entry, interpolation: { escapeValue: false } }));
 			}
 		});
-	} else {
-		// 同步解压所有文件
-		zip.extractAllTo(destPath, true);
+		return;
+	}
+	zip.extractAllTo(destPath, true);
+}
+
+function extractTarEntriesSync(tarPath, destPath, entries = []) {
+	const wanted = new Set((entries ?? []).map((entry) => normalizeArchiveEntryPath(entry)).filter(Boolean));
+	tar.x({
+		file: tarPath,
+		cwd: destPath,
+		sync: true,
+		filter: (entryPath) => {
+			if (wanted.size === 0) {
+				return true;
+			}
+			const normalized = normalizeArchiveEntryPath(entryPath);
+			return wanted.has(normalized);
+		},
+	});
+
+	if (wanted.size === 0) {
+		return;
+	}
+	for (const entry of wanted) {
+		if (!isFileExist(path.join(destPath, entry))) {
+			logger.debug(t('lzc_cli.lib.utils.unzip_sync_not_exist_file_log', `压缩包中没有找到 {{ entry }} 文件`, { entry, interpolation: { escapeValue: false } }));
+		}
+	}
+}
+
+export function extractLpkSync(lpkPath, destPath, entries = []) {
+	if (!isFileExist(lpkPath)) {
+		throw t('lzc_cli.lib.utils.unzip_sync_not_exist_fail', `{{ zipPath }} 找不到该文件`, { zipPath: lpkPath, interpolation: { escapeValue: false } });
+	}
+
+	fs.mkdirSync(destPath, { recursive: true });
+	const format = detectLpkArchiveFormatSync(lpkPath);
+	if (format === 'zip') {
+		extractZipEntriesSync(lpkPath, destPath, entries);
+		return;
 	}
+	if (format === 'tar') {
+		extractTarEntriesSync(lpkPath, destPath, entries);
+		return;
+	}
+	throw new Error(`Unsupported LPK archive format: ${lpkPath}`);
+}
+
+export function unzipSync(zipPath, destPath, entries = []) {
+	extractLpkSync(zipPath, destPath, entries);
 }
 
 export async function selectSshPublicKey(avaiableKeys) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lazycatcloud/lzc-cli",
-	"version": "1.3.17",
+	"version": "2.0.0-pre.1",
 	"description": "lazycat cloud developer kit",
 	"scripts": {
 		"release": "release-it patch",
@@ -34,7 +34,6 @@
 		"@lazycatcloud/sdk": "^0.1.423",
 		"adm-zip": "^0.5.16",
 		"archiver": "^7.0.1",
-		"axios": "^1.7.7",
 		"chalk": "^5.3.0",
 		"chokidar": "^3.6.0",
 		"command-exists": "^1.2.9",
@@ -86,6 +85,7 @@
 	},
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org",
-		"access": "public"
+		"access": "public",
+		"tag": "lpkv2"
 	}
 }

package/scripts/cli.js

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

package/scripts/smoke/frontend-dev-entry.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+
+async function loadPlaywright() {
+  const require = createRequire(import.meta.url);
+  const hints = [
+    process.env.LZC_CLI_PLAYWRIGHT_MODULE,
+    path.join(process.cwd(), 'node_modules', 'playwright'),
+    '/tmp/pw-lzc-test/node_modules/playwright',
+    'playwright',
+  ].filter(Boolean);
+  for (const hint of hints) {
+    try {
+      const resolved = require.resolve(hint);
+      return await import(pathToFileURL(resolved).href);
+    } catch {}
+    try {
+      return await import(hint);
+    } catch {}
+  }
+  throw new Error('playwright module not found; set LZC_CLI_PLAYWRIGHT_MODULE or install playwright');
+}
+
+function getArg(name, fallback = '') {
+  const prefix = `--${name}=`;
+  const hit = process.argv.find((arg) => arg.startsWith(prefix));
+  return hit ? hit.slice(prefix.length) : fallback;
+}
+
+function requireArg(name) {
+  const value = getArg(name);
+  if (!value) {
+    throw new Error(`missing --${name}`);
+  }
+  return value;
+}
+
+const mode = requireArg('mode');
+const target = requireArg('url');
+const screenshot = getArg('screenshot');
+const username = getArg('username');
+const password = getArg('password');
+const expectedTitle = getArg('title');
+const requireTexts = getArg('require-text').split('||').map((item) => item.trim()).filter(Boolean);
+const forbidTexts = getArg('forbid-text').split('||').map((item) => item.trim()).filter(Boolean);
+
+const playwright = await loadPlaywright();
+const chromium = playwright.chromium || playwright.default?.chromium || playwright["module.exports"]?.chromium;
+if (!chromium) {
+  throw new Error("playwright chromium export not found");
+}
+const browser = await chromium.launch({ headless: true });
+const page = await browser.newPage();
+try {
+  await page.goto(target, { waitUntil: 'domcontentloaded', timeout: 120000 });
+  if (page.url().includes('/sys/login')) {
+    if (!username || !password) {
+      throw new Error('login required but --username/--password not provided');
+    }
+    await page.fill('#username', username);
+    await page.fill('#password', password);
+    await Promise.all([
+      page.waitForURL((url) => !url.toString().includes('/sys/login'), { timeout: 120000 }),
+      page.getByRole('button', { name: 'Login' }).click(),
+    ]);
+  }
+  await page.waitForLoadState('networkidle');
+  if (mode === 'ready') {
+    await page.reload({ waitUntil: 'networkidle', timeout: 120000 });
+  }
+  const body = await page.locator('body').innerText();
+  const title = await page.title();
+  if (expectedTitle && title !== expectedTitle) {
+    throw new Error(`unexpected title: ${title}`);
+  }
+  for (const text of requireTexts) {
+    if (!body.includes(text)) {
+      throw new Error(`required text missing: ${text}`);
+    }
+  }
+  for (const text of forbidTexts) {
+    if (body.includes(text)) {
+      throw new Error(`forbidden text found: ${text}`);
+    }
+  }
+  if (screenshot) {
+    fs.mkdirSync(path.dirname(screenshot), { recursive: true });
+    await page.screenshot({ path: screenshot, fullPage: true });
+  }
+  console.log(JSON.stringify({
+    ok: true,
+    mode,
+    url: page.url(),
+    title,
+    body_head: body.slice(0, 400),
+    screenshot,
+  }, null, 2));
+} finally {
+  await browser.close();
+}

package/scripts/smoke/template-project.mjs

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+import { mkdtempSync, rmSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+
+const cliRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', '..');
+const cliEntrypoint = path.join(cliRoot, 'scripts', 'cli.js');
+const frontendSmokeEntrypoint = path.join(cliRoot, 'scripts', 'smoke', 'frontend-dev-entry.mjs');
+
+function getArg(name, fallback = '') {
+	const prefix = `--${name}=`;
+	const hit = process.argv.find((arg) => arg.startsWith(prefix));
+	return hit ? hit.slice(prefix.length) : fallback;
+}
+
+function hasFlag(name) {
+	return process.argv.includes(`--${name}`);
+}
+
+function normalizeBoxName(input) {
+	return String(input || '').trim().replace(/\.heiyu\.space$/i, '');
+}
+
+async function capture(command, args, options = {}) {
+	return await new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd: options.cwd || process.cwd(),
+			env: { ...process.env, ...(options.env || {}) },
+			stdio: ['pipe', 'pipe', 'pipe'],
+			shell: false,
+		});
+		let stdout = '';
+		let stderr = '';
+		child.stdout.on('data', (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr.on('data', (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.on('error', reject);
+		child.on('close', (code) => {
+			if (code === 0) {
+				resolve({ stdout, stderr });
+				return;
+			}
+			reject(new Error(`${command} ${args.join(' ')} failed with code ${code}\n${stdout}\n${stderr}`));
+		});
+		child.stdin.end(options.stdinText || '');
+	});
+}
+
+function spawnStreaming(command, args, options = {}) {
+	const child = spawn(command, args, {
+		cwd: options.cwd || process.cwd(),
+		env: { ...process.env, ...(options.env || {}) },
+		stdio: ['pipe', 'pipe', 'pipe'],
+		shell: false,
+	});
+	let stdout = '';
+	let stderr = '';
+	child.stdout.on('data', (chunk) => {
+		const text = chunk.toString();
+		stdout += text;
+		process.stdout.write(text);
+	});
+	child.stderr.on('data', (chunk) => {
+		const text = chunk.toString();
+		stderr += text;
+		process.stderr.write(text);
+	});
+	if (options.stdinText) {
+		child.stdin.write(options.stdinText);
+	}
+	child.stdin.end();
+	return { child, getStdout: () => stdout, getStderr: () => stderr };
+}
+
+async function runCli(projectDir, argv, options = {}) {
+	const { stdout, stderr } = await capture(process.execPath, [cliEntrypoint, ...argv], {
+		cwd: projectDir,
+		stdinText: options.stdinText || '',
+	});
+	if (stdout.trim()) {
+		process.stdout.write(stdout);
+	}
+	if (stderr.trim()) {
+		process.stderr.write(stderr);
+	}
+	return { stdout, stderr };
+}
+
+async function runSmoke(argv, options = {}) {
+	const { stdout, stderr } = await capture(process.execPath, [frontendSmokeEntrypoint, ...argv], options);
+	if (stdout.trim()) {
+		process.stdout.write(stdout);
+	}
+	if (stderr.trim()) {
+		process.stderr.write(stderr);
+	}
+	return JSON.parse(stdout);
+}
+
+async function readDefaultBoxName() {
+	const { stdout } = await capture(process.execPath, [cliEntrypoint, 'box', 'default']);
+	const box = normalizeBoxName(stdout.trim());
+	if (!box) {
+		throw new Error('default box is empty');
+	}
+	return box;
+}
+
+function extractTarEntry(lpkPath, entryName) {
+	const result = spawnSync('tar', ['-xOf', lpkPath, entryName], { encoding: 'utf8' });
+	if (result.status !== 0) {
+		throw new Error(`extract ${entryName} failed\n${result.stdout}\n${result.stderr}`);
+	}
+	return result.stdout;
+}
+
+function assert(condition, message) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+async function waitForOutput(getText, pattern, timeoutMs = 30000) {
+	const startedAt = Date.now();
+	while (Date.now() - startedAt <= timeoutMs) {
+		if (pattern.test(getText())) {
+			return;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 200));
+	}
+	throw new Error(`timeout waiting for output: ${String(pattern)}`);
+}
+
+async function retry(action, timeoutMs = 30000, intervalMs = 1000) {
+	const startedAt = Date.now();
+	let lastError = null;
+	while (Date.now() - startedAt <= timeoutMs) {
+		try {
+			return await action();
+		} catch (error) {
+			lastError = error;
+			await new Promise((resolve) => setTimeout(resolve, intervalMs));
+		}
+	}
+	throw lastError || new Error('retry timeout');
+}
+
+async function verifyReleaseLayout(projectDir, expectedPackage, expectedSubdomain) {
+	const lpkPath = path.join(projectDir, 'release.lpk');
+	await runCli(projectDir, ['project', 'release', '-o', lpkPath]);
+	const manifestText = extractTarEntry(lpkPath, 'manifest.yml');
+	const packageText = extractTarEntry(lpkPath, 'package.yml');
+	assert(!manifestText.includes('injects:'), 'release manifest must not contain injects');
+	assert(!manifestText.includes('name:'), 'release manifest must not contain static name');
+	assert(!manifestText.includes('description:'), 'release manifest must not contain static description');
+	assert(packageText.includes(`package: ${expectedPackage}`), 'package.yml missing package id');
+	assert(manifestText.includes(`subdomain: ${expectedSubdomain}`), 'release manifest missing subdomain');
+}
+
+async function smokeNotReadyPage({ url, title, requireText = [], username, password, screenshot }) {
+	await runSmoke([
+		'--mode=not-ready',
+		`--url=${url}`,
+		`--username=${username}`,
+		`--password=${password}`,
+		`--title=${title}`,
+		`--require-text=${requireText.join('||')}`,
+		`--screenshot=${screenshot}`,
+	]);
+}
+
+async function smokeReadyPage({ url, title, requireText, forbidText, username, password, screenshot }) {
+	await runSmoke([
+		'--mode=ready',
+		`--url=${url}`,
+		`--username=${username}`,
+		`--password=${password}`,
+		`--title=${title}`,
+		`--require-text=${requireText.join('||')}`,
+		`--forbid-text=${forbidText.join('||')}`,
+		`--screenshot=${screenshot}`,
+	]);
+}
+
+async function uninstallPackage(pkgId) {
+	await capture(process.execPath, [cliEntrypoint, 'lpk', 'uninstall', pkgId]);
+}
+
+async function runHelloVue(projectDir, appName, boxName, username, password) {
+	const pkgId = `cloud.lazycat.app.${appName}.dev`;
+	const url = `https://${appName}.${boxName}.heiyu.space`;
+	try {
+		await verifyReleaseLayout(projectDir, `cloud.lazycat.app.${appName}`, appName);
+		await runCli(projectDir, ['project', 'deploy']);
+		await runCli(projectDir, ['project', 'start', '--restart']);
+		await runCli(projectDir, ['project', 'exec', '--tty=false', 'pwd']);
+		await smokeNotReadyPage({
+			url,
+			title: 'Frontend Dev',
+			username,
+			password,
+			screenshot: path.join(projectDir, 'hello-vue-not-ready.png'),
+		});
+		const vite = spawnStreaming('npm', ['run', 'dev'], { cwd: projectDir });
+		try {
+			await waitForOutput(vite.getStdout, /ready in|Local:\s+http:\/\/localhost:3000\//, 30000);
+			await retry(async () => {
+				await smokeReadyPage({
+					url,
+					title: 'Vite + Vue + TS',
+					requireText: ['Welcome to Lazycat Microservice', 'Open Developer Docs', 'Fast local iteration'],
+					forbidText: ['Frontend dev server is not ready', 'Dev machine is offline', 'Dev machine is not linked yet'],
+					username,
+					password,
+					screenshot: path.join(projectDir, 'hello-vue-ready.png'),
+				});
+			}, 30000, 1000);
+		} finally {
+			vite.child.kill('SIGINT');
+		}
+	} finally {
+		await uninstallPackage(pkgId).catch(() => {});
+	}
+}
+
+async function runTodolistGolang(projectDir, appName, boxName, username, password) {
+	const pkgId = `cloud.lazycat.app.${appName}.dev`;
+	const url = `https://${appName}.${boxName}.heiyu.space`;
+	try {
+		await verifyReleaseLayout(projectDir, `cloud.lazycat.app.${appName}`, appName);
+		await runCli(projectDir, ['project', 'deploy']);
+		await runCli(projectDir, ['project', 'start', '--restart']);
+		const execResult = await runCli(projectDir, ['project', 'exec', '--tty=false', 'pwd']);
+		assert(execResult.stdout.includes('/lzcapp/cache/project-mirror'), 'project exec should enter project mirror workdir');
+		await smokeNotReadyPage({
+			url,
+			title: 'Backend Dev',
+			requireText: ['Backend dev service is not ready', 'project sync --watch', 'project exec /bin/sh', 'Expected local port: 3000'],
+			username,
+			password,
+			screenshot: path.join(projectDir, 'todolist-golang-not-ready.png'),
+		});
+	} finally {
+		await uninstallPackage(pkgId).catch(() => {});
+	}
+}
+
+async function runTodolistPython(projectDir, appName, boxName, username, password) {
+	const pkgId = `cloud.lazycat.app.${appName}.dev`;
+	const url = `https://${appName}.${boxName}.heiyu.space`;
+	try {
+		await verifyReleaseLayout(projectDir, `cloud.lazycat.app.${appName}`, appName);
+		await runCli(projectDir, ['project', 'deploy']);
+		await runCli(projectDir, ['project', 'start', '--restart']);
+		const execResult = await runCli(projectDir, ['project', 'exec', '--tty=false', 'pwd']);
+		assert(execResult.stdout.includes('/lzcapp/cache/project-mirror'), 'project exec should enter project mirror workdir');
+		await retry(async () => {
+			await smokeReadyPage({
+				url,
+				title: 'Lazycat Python Todo Template',
+				requireText: ['Todo demo powered by Flask API', 'Open Developer Docs', 'Todo quick demo'],
+				forbidText: ['Python dev service is not ready'],
+				username,
+				password,
+				screenshot: path.join(projectDir, 'todolist-python-ready.png'),
+			});
+		}, 45000, 1000);
+	} finally {
+		await uninstallPackage(pkgId).catch(() => {});
+	}
+}
+
+async function main() {
+	const template = getArg('template', 'hello-vue');
+	const username = getArg('username', 'c');
+	const password = getArg('password', 'ccc123');
+	const keep = hasFlag('keep');
+	const boxName = normalizeBoxName(getArg('box')) || await readDefaultBoxName();
+	const workspace = mkdtempSync(path.join(os.tmpdir(), `lzc-cli-smoke-${template}-`));
+	const appName = `${template}-smoke-${Date.now().toString(36)}`.replace(/[^a-z0-9-]/g, '-');
+	console.log(`workspace=${workspace}`);
+	console.log(`box=${boxName}`);
+	console.log(`app=${appName}`);
+	try {
+		await runCli(workspace, ['project', 'create', appName, '--template', template], { stdinText: '\n' });
+		const projectDir = path.join(workspace, appName);
+		if (template === 'hello-vue') {
+			await runHelloVue(projectDir, appName, boxName, username, password);
+		} else if (template === 'todolist-golang') {
+			await runTodolistGolang(projectDir, appName, boxName, username, password);
+		} else if (template === 'todolist-python') {
+			await runTodolistPython(projectDir, appName, boxName, username, password);
+		} else {
+			throw new Error(`unsupported template: ${template}`);
+		}
+		console.log(JSON.stringify({ ok: true, template, workspace, boxName, appName }, null, 2));
+	} finally {
+		if (!keep) {
+			rmSync(workspace, { recursive: true, force: true });
+		}
+	}
+}
+
+main().catch((error) => {
+	console.error(error?.stack || String(error));
+	process.exit(1);
+});

package/template/_lpk/README.md

@@ -1,6 +1,16 @@
-
 # 懒猫云应用
 
+## 第一次部署（先看到结果）
+```
+lzc-cli project deploy
+lzc-cli project info
+```
+
+默认情况下，project 命令在存在 `lzc-build.dev.yml` 时会优先使用它。
+每个命令都会打印实际使用的 `Build config`。
+如果要操作 `lzc-build.yml`，请显式加上 `--release`。
+如果是前端模板，`project deploy` 会按 `buildscript` 自动安装依赖并完成构建，不需要额外先执行 `npm install`。
+
 ## 构建
 ```
 lzc-cli project build -o you-awesome.lpk
@@ -9,12 +19,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,18 @@
+# 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