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

package/lib/app/lpk_embed_images.js

@@ -0,0 +1,257 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+import logger from 'loglevel';
+import * as tar from 'tar';
+import { isFileExist } from '../utils.js';
+import { DebugBridge } from '../debug_bridge.js';
+import shellApi from '../shellapi.js';
+import { t } from '../i18n/index.js';
+import { resolveBuildRemoteFromFile } from '../build_remote.js';
+
+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 sha256Buffer(buffer) {
+	return crypto.createHash('sha256').update(buffer).digest('hex');
+}
+
+async function copyFileToOciBlob(sourcePath, blobsDir) {
+	const { digest, size } = await sha256File(sourcePath);
+	const blobPath = path.join(blobsDir, digest);
+	if (!isFileExist(blobPath)) {
+		fs.copyFileSync(sourcePath, blobPath);
+	}
+	return { digest, size };
+}
+
+function copyBufferToOciBlob(content, blobsDir) {
+	const digest = sha256Buffer(content);
+	const blobPath = path.join(blobsDir, digest);
+	if (!isFileExist(blobPath)) {
+		fs.writeFileSync(blobPath, content);
+	}
+	return { digest, size: content.length };
+}
+
+function collectImagesFromManifest(manifest) {
+	const images = [];
+
+	const appImage = manifest?.application?.image;
+	if (typeof appImage === 'string' && appImage.trim()) {
+		images.push(appImage.trim());
+	}
+
+	const services = manifest?.services;
+	if (services && typeof services === 'object') {
+		for (const service of Object.values(services)) {
+			if (typeof service?.image === 'string' && service.image.trim()) {
+				images.push(service.image.trim());
+			}
+		}
+	}
+
+	return [...new Set(images)];
+}
+
+function replaceManifestImageToDigest(manifest, imageDigestMap) {
+	let replaced = 0;
+	const unresolved = [];
+	if (!imageDigestMap || imageDigestMap.size === 0) {
+		return { replaced, unresolved };
+	}
+
+	const replaceOne = (sourceImage) => {
+		if (typeof sourceImage !== 'string') {
+			return sourceImage;
+		}
+		const image = sourceImage.trim();
+		if (!image || image.startsWith('sha256:')) {
+			return sourceImage;
+		}
+		const digest = imageDigestMap.get(image);
+		if (!digest) {
+			unresolved.push(image);
+			return sourceImage;
+		}
+		if (digest !== sourceImage) {
+			replaced += 1;
+		}
+		return digest;
+	};
+
+	if (manifest?.application?.image) {
+		manifest.application.image = replaceOne(manifest.application.image);
+	}
+
+	const services = manifest?.services;
+	if (services && typeof services === 'object') {
+		for (const service of Object.values(services)) {
+			if (service && typeof service === 'object' && typeof service.image === 'string') {
+				service.image = replaceOne(service.image);
+			}
+		}
+	}
+
+	return {
+		replaced,
+		unresolved: [...new Set(unresolved)],
+	};
+}
+
+async function convertDockerArchiveToOciLayout(dockerArchivePath, imageRootDir) {
+	const extractDir = fs.mkdtempSync('.lzc-cli-docker-archive');
+	try {
+		await tar.x({
+			file: dockerArchivePath,
+			cwd: extractDir,
+		});
+
+		const dockerManifestFile = path.join(extractDir, 'manifest.json');
+		if (!isFileExist(dockerManifestFile)) {
+			throw new Error(t('lzc_cli.lib.app.lpk_build.convert_archive_manifest_missing', 'manifest.json not found in docker archive'));
+		}
+
+		const dockerManifests = JSON.parse(fs.readFileSync(dockerManifestFile, 'utf-8'));
+		if (!Array.isArray(dockerManifests) || dockerManifests.length === 0) {
+			throw new Error(t('lzc_cli.lib.app.lpk_build.convert_archive_manifest_invalid', 'invalid docker archive manifest'));
+		}
+
+		const blobsDir = path.join(imageRootDir, 'blobs', 'sha256');
+		fs.mkdirSync(blobsDir, { recursive: true });
+
+		const indexDescriptors = [];
+		const imageDigestMap = new Map();
+		for (const item of dockerManifests) {
+			const configFile = item?.Config ? path.join(extractDir, item.Config) : '';
+			if (!configFile || !isFileExist(configFile)) {
+				throw new Error(t('lzc_cli.lib.app.lpk_build.convert_archive_config_missing', `config file missing in docker archive: ${item?.Config || ''}`));
+			}
+
+			const config = await copyFileToOciBlob(configFile, blobsDir);
+			const imageDigest = `sha256:${config.digest}`;
+			const layers = [];
+			for (const layer of item?.Layers ?? []) {
+				const layerFile = path.join(extractDir, layer);
+				if (!isFileExist(layerFile)) {
+					throw new Error(t('lzc_cli.lib.app.lpk_build.convert_archive_layer_missing', `layer file missing in docker archive: ${layer}`));
+				}
+				const layerBlob = await copyFileToOciBlob(layerFile, blobsDir);
+				layers.push({
+					mediaType: 'application/vnd.oci.image.layer.v1.tar',
+					digest: `sha256:${layerBlob.digest}`,
+					size: layerBlob.size,
+				});
+			}
+
+			const manifestContent = Buffer.from(
+				JSON.stringify({
+					schemaVersion: 2,
+					mediaType: 'application/vnd.oci.image.manifest.v1+json',
+					config: {
+						mediaType: 'application/vnd.oci.image.config.v1+json',
+						digest: `sha256:${config.digest}`,
+						size: config.size,
+					},
+					layers,
+				}),
+			);
+			const imageManifest = copyBufferToOciBlob(manifestContent, blobsDir);
+			const descriptor = {
+				mediaType: 'application/vnd.oci.image.manifest.v1+json',
+				digest: `sha256:${imageManifest.digest}`,
+				size: imageManifest.size,
+			};
+			const refName = item?.RepoTags?.[0];
+			if (typeof refName === 'string' && refName) {
+				descriptor.annotations = {
+					'org.opencontainers.image.ref.name': refName,
+				};
+			}
+			for (const repoTag of item?.RepoTags ?? []) {
+				if (typeof repoTag !== 'string' || !repoTag) {
+					continue;
+				}
+				imageDigestMap.set(repoTag, imageDigest);
+			}
+			indexDescriptors.push(descriptor);
+		}
+
+		fs.mkdirSync(imageRootDir, { recursive: true });
+		fs.writeFileSync(path.join(imageRootDir, 'oci-layout'), JSON.stringify({ imageLayoutVersion: '1.0.0' }));
+		fs.writeFileSync(
+			path.join(imageRootDir, 'index.json'),
+			JSON.stringify(
+				{
+					schemaVersion: 2,
+					manifests: indexDescriptors,
+				},
+				null,
+				2,
+			),
+		);
+		return imageDigestMap;
+	} finally {
+		fs.rmSync(extractDir, { recursive: true, force: true });
+	}
+}
+
+export async function embedImagesToTempDir(manifest, tempDir) {
+	const images = collectImagesFromManifest(manifest);
+	if (images.length === 0) {
+		logger.warn(t('lzc_cli.lib.app.lpk_build.embed_images_skip_no_image', 'No image field found in manifest, skip embedding images'));
+		return;
+	}
+
+	const buildRemote = resolveBuildRemoteFromFile(process.cwd());
+	if (!buildRemote) {
+		await shellApi.init();
+	}
+	const bridge = new DebugBridge(process.cwd(), buildRemote);
+	await bridge.init();
+
+	for (const image of images) {
+		if (image.includes('$')) {
+			throw new Error(t('lzc_cli.lib.app.lpk_build.embed_images_placeholder_fail', `Found unresolved image placeholder: ${image}`));
+		}
+
+		if (image.startsWith('sha256:')) {
+			logger.debug(`skip pull image by digest id: ${image}`);
+			continue;
+		}
+		logger.info(t('lzc_cli.lib.app.lpk_build.embed_images_pull_tips', `Pull image on box: ${image}`));
+		await bridge.lzcDockerPull(image);
+	}
+
+	const dockerArchivePath = path.join(tempDir, 'images.docker.tar');
+	logger.info(t('lzc_cli.lib.app.lpk_build.embed_images_export_tips', 'Export images from box to OCI layout'));
+	await bridge.lzcDockerSave(images, dockerArchivePath);
+
+	const imageDigestMap = await convertDockerArchiveToOciLayout(dockerArchivePath, path.join(tempDir, 'images'));
+	const { replaced, unresolved } = replaceManifestImageToDigest(manifest, imageDigestMap);
+	if (replaced > 0) {
+		logger.info(t('lzc_cli.lib.app.lpk_build.embed_images_rewrite_manifest_tips', `Rewrite ${replaced} image references in manifest.yml`));
+	}
+	if (unresolved.length > 0) {
+		throw new Error(
+			t('lzc_cli.lib.app.lpk_build.embed_images_rewrite_manifest_unresolved_fail', `Failed to rewrite image references to sha256 digest: ${unresolved.join(', ')}`),
+		);
+	}
+	fs.rmSync(dockerArchivePath, { force: true });
+}

package/lib/app/lpk_installer.js

@@ -1,13 +1,15 @@
 import logger from 'loglevel';
 import fs from 'node:fs';
 import path from 'node:path';
-import { loadFromYaml, Downloader, unzipSync } from '../utils.js';
+import { Downloader, extractLpkSync } from '../utils.js';
+import { loadEffectiveManifestFromFiles } from '../package_info.js';
 import { DebugBridge } from '../debug_bridge.js';
 import shellapi from '../shellapi.js';
 import { t } from '../i18n/index.js';
 import { triggerApk } from './apkshell.js';
+import { resolveBuildRemoteFromFile } from '../build_remote.js';
 
-export const installConfig = { apk: true, sshPrivateKey: '' };
+export const installConfig = { apk: true };
 // 从一个目录中找出修改时间最新的包
 function findOnceLpkByDir(dir = process.cwd()) {
 	const pkg = fs
@@ -20,7 +22,7 @@ function findOnceLpkByDir(dir = process.cwd()) {
 			return b.mtime - a.mtime;
 		})
 		.find((entry) => {
-			return entry.filename.endsWith('.lpk');
+			return entry.filename.endsWith('.lpk') || entry.filename.endsWith('.lpk.tar');
 		});
 	return pkg?.filename ? path.resolve(dir, pkg.filename) : '';
 }
@@ -94,8 +96,8 @@ export class LpkInstaller {
 		const tempDir = fs.mkdtempSync('.lzc-cli-install');
 		let manifest;
 		try {
-			unzipSync(pkgPath, tempDir, ['manifest.yml', 'icon.png']);
-			manifest = loadFromYaml(path.join(tempDir, 'manifest.yml'));
+			extractLpkSync(pkgPath, tempDir, ['manifest.yml', 'package.yml', 'icon.png']);
+			manifest = loadEffectiveManifestFromFiles(path.join(tempDir, 'manifest.yml')).manifest;
 			if (!manifest['application']['subdomain']) {
 				throw t('lzc_cli.lib.app.lpk_installer.install_from_file_manifest_not_exists_app_subdomain_fail', 'manifest.yml 中的 `application.subdomain` 字段不能为空');
 			}
@@ -115,24 +117,30 @@ export class LpkInstaller {
 		}
 
 		try {
-			const bridge = new DebugBridge();
-			await bridge.init(installConfig.sshPrivateKey);
+			const buildRemote = resolveBuildRemoteFromFile(process.cwd());
+			if (!buildRemote && (!shellapi.uid || !shellapi.boxname)) {
+				await shellapi.init();
+			}
+			const bridge = new DebugBridge(process.cwd(), buildRemote);
+			await bridge.init();
 			logger.info(t('lzc_cli.lib.app.lpk_installer.install_from_file_start_tips', '开始安装应用'));
 			await bridge.install(pkgPath, manifest ? manifest['package'] : '');
 			logger.info('\n');
 			logger.info(t('lzc_cli.lib.app.lpk_installer.install_from_file_success_tips', `安装成功！`));
 			if (manifest) {
+				const boxname = buildRemote ? buildRemote.boxname : shellapi.boxname;
 				logger.info(
 					t('lzc_cli.lib.app.lpk_installer.install_from_file_done_tips', `👉 请在浏览器中访问 https://{{ subdomain }}.{{ boxname }}.heiyu.space`, {
 						subdomain: manifest['application']['subdomain'],
-						boxname: shellapi.boxname,
+						boxname,
 						interpolation: { escapeValue: false },
 					}),
 				);
 				logger.info(t('lzc_cli.lib.app.lpk_installer.install_from_file_login_tips', `👉 并使用微服的用户名和密码登录`));
 			}
 		} catch (error) {
-			logger.error(t('lzc_cli.lib.app.lpk_installer.install_from_file_fail_tips', `安装失败: {{ error }}`, { error, interpolation: { escapeValue: false } }));
+			const errorMsg = error instanceof Error ? error.message : String(error);
+			logger.error(t('lzc_cli.lib.app.lpk_installer.install_from_file_fail_tips', `安装失败: {{ error }}`, { error: errorMsg, interpolation: { escapeValue: false } }));
 		}
 	}
 }

package/lib/app/manifest_build.js

@@ -0,0 +1,259 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const ENV_KEY_REGEXP = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const BUILD_DIRECTIVE_PREFIX = '#@build';
+
+function normalizeDirectiveValue(rawValue) {
+	const trimmed = String(rawValue ?? '').trim();
+	if (!trimmed) {
+		return '';
+	}
+	if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+		return trimmed.slice(1, -1);
+	}
+	return trimmed;
+}
+
+export function normalizeBuildEnvEntries(rawEnvs) {
+	if (rawEnvs === undefined || rawEnvs === null) {
+		return [];
+	}
+	if (!Array.isArray(rawEnvs)) {
+		throw new Error('envs must be a string array');
+	}
+	const normalized = [];
+	const seen = new Set();
+	for (let index = 0; index < rawEnvs.length; index += 1) {
+		const rawEntry = rawEnvs[index];
+		if (typeof rawEntry !== 'string') {
+			throw new Error(`envs[${index}] must be a string`);
+		}
+		const entry = rawEntry.trim();
+		if (!entry) {
+			throw new Error(`envs[${index}] must not be empty`);
+		}
+		const equalIndex = entry.indexOf('=');
+		if (equalIndex <= 0) {
+			throw new Error(`envs[${index}] must use KEY=VALUE format`);
+		}
+		const key = entry.slice(0, equalIndex).trim();
+		const value = entry.slice(equalIndex + 1);
+		if (!ENV_KEY_REGEXP.test(key)) {
+			throw new Error(`envs[${index}] has invalid key "${key}"`);
+		}
+		if (seen.has(key)) {
+			throw new Error(`envs contains duplicated key "${key}"`);
+		}
+		seen.add(key);
+		normalized.push(`${key}=${value}`);
+	}
+	return normalized;
+}
+
+export function buildVarsFromEnvEntries(rawEnvs) {
+	const envs = normalizeBuildEnvEntries(rawEnvs);
+	const result = {};
+	for (const entry of envs) {
+		const equalIndex = entry.indexOf('=');
+		const key = entry.slice(0, equalIndex);
+		const value = entry.slice(equalIndex + 1);
+		result[key] = value;
+	}
+	return result;
+}
+
+function parseBuildDirective(line) {
+	const trimmed = String(line ?? '').trim();
+	if (!trimmed.startsWith(BUILD_DIRECTIVE_PREFIX)) {
+		return null;
+	}
+	const body = trimmed.slice(BUILD_DIRECTIVE_PREFIX.length).trim();
+	if (!body) {
+		throw new Error('build directive is empty');
+	}
+	const spaceIndex = body.indexOf(' ');
+	const command = (spaceIndex >= 0 ? body.slice(0, spaceIndex) : body).trim();
+	const args = (spaceIndex >= 0 ? body.slice(spaceIndex + 1) : '').trim();
+	if (!command) {
+		throw new Error('build directive command is empty');
+	}
+	return {
+		command,
+		args,
+	};
+}
+
+function evaluateBuildCondition(expr, context) {
+	const normalized = String(expr ?? '').trim();
+	if (!normalized) {
+		throw new Error('build if condition is empty');
+	}
+
+	let match = normalized.match(/^profile\s*(==|=|!=)\s*(.+)$/);
+	if (match) {
+		const expected = normalizeDirectiveValue(match[2]);
+		const actual = String(context.profile ?? '');
+		return match[1] === '!=' ? actual !== expected : actual === expected;
+	}
+
+	match = normalized.match(/^env\.([A-Za-z_][A-Za-z0-9_]*)\s*(==|=|!=)\s*(.+)$/);
+	if (match) {
+		const key = match[1];
+		const expected = normalizeDirectiveValue(match[3]);
+		const actual = String(context.envs?.[key] ?? '');
+		return match[2] === '!=' ? actual !== expected : actual === expected;
+	}
+
+	match = normalized.match(/^env\.([A-Za-z_][A-Za-z0-9_]*)$/);
+	if (match) {
+		const key = match[1];
+		return String(context.envs?.[key] ?? '').trim() !== '';
+	}
+
+	throw new Error(`unsupported build condition "${normalized}"`);
+}
+
+function resolveIncludePath(rawPath, rootDir) {
+	const normalized = normalizeDirectiveValue(rawPath);
+	if (!normalized) {
+		throw new Error('build include path is empty');
+	}
+	if (path.isAbsolute(normalized)) {
+		return normalized;
+	}
+	return path.resolve(rootDir, normalized);
+}
+
+function formatSourceRef(filePath, lineNumber) {
+	return `${filePath}:${lineNumber}`;
+}
+
+function indentIncludedText(text, indent) {
+	if (!text) {
+		return '';
+	}
+	const prefix = String(indent ?? '');
+	return String(text)
+		.split('\n')
+		.map((line) => {
+			if (!line) {
+				return '';
+			}
+			return `${prefix}${line}`;
+		})
+		.join('\n');
+}
+
+function processManifestText(rawText, context, options) {
+	const filePath = options.filePath;
+	const rootDir = options.rootDir;
+	const allowDirectives = options.allowDirectives;
+	const lines = String(rawText ?? '').split('\n');
+	const output = [];
+	const stack = [{
+		type: 'root',
+		active: true,
+	}];
+
+	const currentActive = () => stack[stack.length - 1].active;
+
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		const directive = parseBuildDirective(line);
+		if (!directive) {
+			if (currentActive()) {
+				output.push(line);
+			}
+			continue;
+		}
+
+		if (!allowDirectives) {
+			throw new Error(`nested build directive is not allowed in included file at ${formatSourceRef(filePath, index + 1)}`);
+		}
+
+		switch (directive.command) {
+			case 'if': {
+				const parentActive = currentActive();
+				const condition = evaluateBuildCondition(directive.args, context);
+				stack.push({
+					type: 'if',
+					parentActive,
+					condition,
+					elseSeen: false,
+					active: parentActive && condition,
+				});
+				break;
+			}
+			case 'else': {
+				if (stack.length === 1 || stack[stack.length - 1].type !== 'if') {
+					throw new Error(`build else without matching if at ${formatSourceRef(filePath, index + 1)}`);
+				}
+				const top = stack[stack.length - 1];
+				if (top.elseSeen) {
+					throw new Error(`duplicate build else at ${formatSourceRef(filePath, index + 1)}`);
+				}
+				top.elseSeen = true;
+				top.active = top.parentActive && !top.condition;
+				break;
+			}
+			case 'end': {
+				if (stack.length === 1 || stack[stack.length - 1].type !== 'if') {
+					throw new Error(`build end without matching if at ${formatSourceRef(filePath, index + 1)}`);
+				}
+				stack.pop();
+				break;
+			}
+			case 'include': {
+				if (!currentActive()) {
+					break;
+				}
+				const lineIndent = line.match(/^\s*/)?.[0] ?? '';
+				const includePath = resolveIncludePath(directive.args, rootDir);
+				if (!fs.existsSync(includePath)) {
+					throw new Error(`build include file not found at ${formatSourceRef(filePath, index + 1)}: ${includePath}`);
+				}
+				const includedText = fs.readFileSync(includePath, 'utf8');
+				const rendered = processManifestText(includedText, context, {
+					filePath: includePath,
+					rootDir,
+					allowDirectives: false,
+				});
+				if (rendered.length > 0) {
+					output.push(indentIncludedText(rendered, lineIndent));
+				}
+				break;
+			}
+			default:
+				throw new Error(`unsupported build directive "${directive.command}" at ${formatSourceRef(filePath, index + 1)}`);
+		}
+	}
+
+	if (stack.length !== 1) {
+		throw new Error(`unclosed build if block in ${filePath}`);
+	}
+
+	return output.join('\n');
+}
+
+export function preprocessManifestText(rawText, context, options = {}) {
+	const filePath = options.filePath || '<manifest>';
+	const rootDir = options.rootDir || process.cwd();
+	return processManifestText(rawText, {
+		profile: String(context?.profile ?? '').trim(),
+		envs: { ...(context?.envs ?? {}) },
+	}, {
+		filePath,
+		rootDir,
+		allowDirectives: true,
+	});
+}
+
+export function preprocessManifestFile(manifestPath, context) {
+	const filePath = path.resolve(manifestPath);
+	const rawText = fs.readFileSync(filePath, 'utf8');
+	return preprocessManifestText(rawText, context, {
+		filePath,
+		rootDir: path.dirname(filePath),
+	});
+}

package/lib/app/project_cp.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as tar from 'tar';
+import logger from 'loglevel';
+import { addProjectTargetOptions, resolveProjectRuntime, ensureProjectServiceRunning } from './project_runtime.js';
+
+function normalizeSourcePath(source) {
+	const sourcePath = path.resolve(process.cwd(), String(source));
+	if (!fs.existsSync(sourcePath)) {
+		throw new Error(`Source path not found: ${sourcePath}`);
+	}
+	return sourcePath;
+}
+
+function createTarStreamForSource(sourcePath) {
+	const sourceName = path.basename(sourcePath);
+	const sourceParent = path.dirname(sourcePath);
+	return tar.c(
+		{
+			cwd: sourceParent,
+			portable: true,
+		},
+		[sourceName],
+	);
+}
+
+export function projectCpCommand() {
+	return {
+		command: 'cp <src> <dest>',
+		desc: 'Copy local files into a project service container',
+		builder: (args) => {
+			args.option('s', {
+				alias: 'service',
+				describe: 'Service name in docker compose project',
+				type: 'string',
+				default: 'app',
+			});
+			addProjectTargetOptions(args);
+		},
+		handler: async ({ src, dest, service, config, dev, release }) => {
+			if (String(dest).includes(':')) {
+				throw new Error('Destination path must not include service prefix');
+			}
+
+			const runtime = await resolveProjectRuntime(process.cwd(), { config, dev, release, command: 'lzc-cli project cp' });
+			logger.info(`Build config: ${runtime.configPath}`);
+			const targetService = String(service || 'app');
+			const containerId = await ensureProjectServiceRunning(runtime, targetService);
+
+			const sourcePath = normalizeSourcePath(src);
+			const tarStream = createTarStreamForSource(sourcePath);
+			const dockerCpArgs = ['cp', '-', `${containerId}:${String(dest)}`];
+
+			logger.debug('project cp service:', targetService);
+			logger.debug('project cp docker cp:', dockerCpArgs.join(' '));
+			await runtime.bridge.lzcDockerPipe(dockerCpArgs, tarStream);
+		},
+	};
+}

package/lib/app/project_deploy.js

@@ -0,0 +1,58 @@
+import logger from 'loglevel';
+import { LpkBuild } from './lpk_build.js';
+import { printProjectInfo } from './project_info.js';
+import { addProjectTargetOptions, resolveProjectRuntime, resolveProjectDeployConfigPath } from './project_runtime.js';
+
+export function isAppContainerNotReadyError(error) {
+	const message = String(error?.message ?? error ?? '');
+	return message.includes('No such container') || message.includes('is not running');
+}
+
+async function syncProjectDevID(runtime, { waitForContainer = false } = {}) {
+	const devId = await runtime.bridge.resolveDevId();
+	logger.info(`Sync dev.id: ${devId || '<empty>'}`);
+	const maxAttempts = waitForContainer ? 30 : 1;
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+		try {
+			await runtime.bridge.syncDevID(runtime.pkgId, devId, runtime.userApp);
+			logger.info('dev id synced successfully.');
+			return;
+		} catch (error) {
+			if (!waitForContainer || !isAppContainerNotReadyError(error) || attempt === maxAttempts) {
+				throw error;
+			}
+			if (attempt === 1) {
+				logger.info('Waiting for app container before syncing dev.id...');
+			}
+			await new Promise((resolve) => setTimeout(resolve, 1000));
+		}
+	}
+}
+
+export function projectDeployCommand() {
+	return {
+		command: 'deploy',
+		desc: 'Build and install project to target box',
+		builder: (args) => {
+			addProjectTargetOptions(args);
+		},
+		handler: async ({ config, dev, release }) => {
+			const configPath = resolveProjectDeployConfigPath(process.cwd(), { config, dev, release, command: 'lzc-cli project deploy' });
+			const runtime = await resolveProjectRuntime(process.cwd(), configPath);
+			logger.info(`Build config: ${runtime.configPath}`);
+
+			const lpkBuild = await new LpkBuild(runtime.projectCwd, runtime.configName, { forceV2: true }).init();
+			lpkBuild.onBeforeBuildPackage(async (options) => {
+				delete options.devshell;
+				return options;
+			});
+			const pkgPath = await lpkBuild.exec();
+
+			logger.info(`Install package: ${pkgPath}`);
+			await runtime.bridge.install(pkgPath, runtime.pkgId);
+			await syncProjectDevID(runtime, { waitForContainer: true });
+			logger.info('Project deployed successfully.');
+			await printProjectInfo(runtime);
+		},
+	};
+}