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

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

@@ -6,6 +6,7 @@ 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 };
 // 从一个目录中找出修改时间最新的包
@@ -20,15 +21,15 @@ 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) : '';
 }
 
 export class LpkInstaller {
-	constructor() { }
+	constructor() {}
 
-	async init() { }
+	async init() {}
 
 	// deploy 构建和安装
 	async deploy(builder) {
@@ -115,24 +116,30 @@ export class LpkInstaller {
 		}
 
 		try {
-			const bridge = new DebugBridge();
+			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,
-						interpolation: { escapeValue: false }
+						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/project_cp.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as tar from 'tar';
+import logger from 'loglevel';
+import { DEFAULT_BUILD_CONFIG_FILE } from '../build_remote.js';
+import { 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',
+			});
+			args.option('c', {
+				alias: 'config',
+				describe: 'Build config file name',
+				type: 'string',
+				default: DEFAULT_BUILD_CONFIG_FILE,
+			});
+		},
+		handler: async ({ src, dest, service, config }) => {
+			if (String(dest).includes(':')) {
+				throw new Error('Destination path must not include service prefix');
+			}
+
+			const runtime = await resolveProjectRuntime(process.cwd(), config);
+			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,33 @@
+import logger from 'loglevel';
+import { LpkBuild } from './lpk_build.js';
+import { resolveProjectRuntime, resolveProjectDeployConfigPath } from './project_runtime.js';
+
+export function projectDeployCommand() {
+	return {
+		command: 'deploy',
+		desc: 'Build and install project to target box',
+		builder: (args) => {
+			args.option('c', {
+				alias: 'config',
+				describe: 'Build config file name',
+				type: 'string',
+			});
+		},
+		handler: async ({ config }) => {
+			const configPath = resolveProjectDeployConfigPath(process.cwd(), config);
+			const runtime = await resolveProjectRuntime(process.cwd(), configPath);
+			logger.info(`Deploy config: ${runtime.configPath}`);
+
+			const lpkBuild = await new LpkBuild(runtime.projectCwd, runtime.configName).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);
+			logger.info('Project deployed successfully.');
+		},
+	};
+}

package/lib/app/project_exec.js

@@ -0,0 +1,45 @@
+import logger from 'loglevel';
+import { DEFAULT_BUILD_CONFIG_FILE } from '../build_remote.js';
+import { resolveProjectRuntime, ensureProjectServiceRunning } from './project_runtime.js';
+
+export function projectExecCommand() {
+	return {
+		command: 'exec [cmd..]',
+		desc: 'Execute command in a project service container',
+		builder: (args) => {
+			args.option('s', {
+				alias: 'service',
+				describe: 'Service name in docker compose project',
+				type: 'string',
+				default: 'app',
+			});
+			args.option('c', {
+				alias: 'config',
+				describe: 'Build config file name',
+				type: 'string',
+				default: DEFAULT_BUILD_CONFIG_FILE,
+			});
+			args.option('t', {
+				alias: 'tty',
+				describe: 'Allocate tty for exec',
+				type: 'boolean',
+				default: true,
+			});
+		},
+		handler: async ({ cmd, service, config, tty }) => {
+			const runtime = await resolveProjectRuntime(process.cwd(), config);
+			const targetService = String(service || 'app');
+			await ensureProjectServiceRunning(runtime, targetService);
+			const execCommand = Array.isArray(cmd) && cmd.length > 0 ? cmd.map((item) => String(item)) : ['/bin/sh'];
+
+			const composeArgs = ['-p', runtime.composeProjectName, 'exec'];
+			if (!tty) {
+				composeArgs.push('-T');
+			}
+			composeArgs.push(targetService, ...execCommand);
+
+			logger.debug('project exec:', composeArgs.join(' '));
+			await runtime.bridge.lzcDockerCompose(composeArgs);
+		},
+	};
+}

package/lib/app/project_info.js

@@ -0,0 +1,106 @@
+import logger from 'loglevel';
+import { DEFAULT_BUILD_CONFIG_FILE } from '../build_remote.js';
+import { resolveProjectRuntime, getProjectDeployInfo, getProjectComposePs, getProjectErrmsgByDeployId } from './project_runtime.js';
+
+function takeFirstLines(text, maxLines = 50) {
+	const lines = String(text ?? '').split(/\r?\n/);
+	const limit = Number.isInteger(maxLines) && maxLines > 0 ? maxLines : 50;
+	if (lines.length <= limit) {
+		return {
+			text: lines.join('\n'),
+			truncated: false,
+		};
+	}
+	return {
+		text: lines.slice(0, limit).join('\n'),
+		truncated: true,
+	};
+}
+
+function trimErrmsgByDockerConfigs(text) {
+	const raw = String(text ?? '');
+	const marker = '---------------docker-configs:-----------';
+	const idx = raw.indexOf(marker);
+	if (idx >= 0) {
+		return raw.slice(0, idx).trim();
+	}
+	return raw.trim();
+}
+
+function resolveTargetUrl(domain) {
+	const rawDomain = String(domain ?? '').trim();
+	if (!rawDomain) {
+		return '';
+	}
+	if (rawDomain.startsWith('http://') || rawDomain.startsWith('https://')) {
+		return rawDomain;
+	}
+	return `https://${rawDomain}`;
+}
+
+export function projectInfoCommand() {
+	return {
+		command: 'info',
+		desc: 'Show project deployment and runtime info',
+		builder: (args) => {
+			args.option('c', {
+				alias: 'config',
+				describe: 'Build config file name',
+				type: 'string',
+				default: DEFAULT_BUILD_CONFIG_FILE,
+			});
+		},
+		handler: async ({ config }) => {
+			const runtime = await resolveProjectRuntime(process.cwd(), config);
+			const deploy = await getProjectDeployInfo(runtime);
+			const instanceStatus = String(deploy.instanceStatus ?? '').trim();
+			const instanceStatusLower = instanceStatus.toLowerCase();
+			const targetMode = runtime.bridge.isBuildRemoteMode() ? 'build-remote' : 'box-shell';
+			const targetUrl = resolveTargetUrl(deploy.domain);
+
+			logger.info(`Target mode: ${targetMode}`);
+			logger.info(`Target box: ${runtime.bridge.boxname}`);
+			if (targetUrl) {
+				logger.info(`Target URL: ${targetUrl}`);
+			}
+			logger.info(`Project package: ${runtime.pkgId}`);
+			logger.info(`Local version: ${deploy.localVersion || '(empty)'}`);
+			logger.info(`Deployed status: ${deploy.appStatus || '(unknown)'}`);
+			logger.info(`Instance status: ${deploy.instanceStatus || '(unknown)'}`);
+			logger.info(`Deployed version: ${deploy.deployedVersion || '(empty)'}`);
+			logger.info(`Current version deployed: ${deploy.currentVersionDeployed ? 'yes' : 'no'}`);
+			if (deploy.deployId) {
+				logger.info(`Deploy DIR: /lzcsys/data/system/pkgm/run/${deploy.deployId}`);
+			}
+
+			if (deploy.isRunning) {
+				logger.info('Project app is running.');
+				const psOutput = await getProjectComposePs(runtime);
+				if (psOutput) {
+					console.log(psOutput);
+				}
+				return;
+			}
+			if (instanceStatusLower.includes('starting')) {
+				logger.info('Project app is starting. Please wait and run "lzc-cli project info" again.');
+				return;
+			}
+			if (instanceStatusLower.includes('error')) {
+				logger.info('Project app is in error state.');
+				const errmsg = await getProjectErrmsgByDeployId(runtime, deploy.deployId);
+				const cleanedErrmsg = trimErrmsgByDockerConfigs(errmsg);
+				if (cleanedErrmsg) {
+					const { text: partialErrmsg, truncated } = takeFirstLines(cleanedErrmsg, 50);
+					logger.info(`Error message (first 50 lines):\n${partialErrmsg}`);
+					if (truncated) {
+						logger.info('Need more logs? Run "lzc-cli project log" for full output.');
+					}
+				} else {
+					logger.info('Error message: (empty)');
+				}
+				return;
+			}
+			logger.info('Project app is not running. Run "lzc-cli project start" first.');
+		},
+	};
+}

package/lib/app/project_log.js

@@ -0,0 +1,67 @@
+import logger from 'loglevel';
+import { DEFAULT_BUILD_CONFIG_FILE } from '../build_remote.js';
+import { resolveProjectRuntime, ensureProjectRunning, ensureProjectServiceRunning, getComposeProject } from './project_runtime.js';
+
+export function projectLogCommand() {
+	return {
+		command: 'log',
+		desc: 'Show logs of project containers',
+		builder: (args) => {
+			args.option('s', {
+				alias: 'service',
+				describe: 'Service name in docker compose project',
+				type: 'string',
+			});
+			args.option('c', {
+				alias: 'config',
+				describe: 'Build config file name',
+				type: 'string',
+				default: DEFAULT_BUILD_CONFIG_FILE,
+			});
+			args.option('f', {
+				alias: 'follow',
+				describe: 'Follow log output',
+				type: 'boolean',
+				default: true,
+			});
+			args.option('tail', {
+				describe: 'Number of lines to show from the end of logs',
+				type: 'number',
+				default: 200,
+			});
+			args.option('since', {
+				describe: 'Show logs since timestamp or relative duration',
+				type: 'string',
+			});
+		},
+		handler: async ({ service, config, follow, tail, since }) => {
+			const runtime = await resolveProjectRuntime(process.cwd(), config);
+			const targetService = String(service ?? '').trim();
+			if (targetService) {
+				await ensureProjectServiceRunning(runtime, targetService);
+			} else {
+				await ensureProjectRunning(runtime);
+				const composeProject = await getComposeProject(runtime);
+				if (!composeProject || !composeProject.status.startsWith('running(')) {
+					throw new Error('Project app is not running. Run "lzc-cli project start" first.');
+				}
+			}
+			const composeArgs = ['-p', runtime.composeProjectName, 'logs'];
+			if (follow) {
+				composeArgs.push('-f');
+			}
+			if (tail !== undefined && tail !== null) {
+				composeArgs.push('--tail', String(tail));
+			}
+			if (since) {
+				composeArgs.push('--since', String(since));
+			}
+			if (targetService) {
+				composeArgs.push(targetService);
+			}
+
+			logger.debug('project log:', composeArgs.join(' '));
+			await runtime.bridge.lzcDockerCompose(composeArgs);
+		},
+	};
+}