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

package/lib/app/project_runtime.js

@@ -0,0 +1,261 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import shellApi from '../shellapi.js';
+import { DebugBridge } from '../debug_bridge.js';
+import { LpkBuild } from './lpk_build.js';
+import { isUserApp } from '../utils.js';
+import { resolveBuildRemoteFromFile, DEFAULT_BUILD_CONFIG_FILE } from '../build_remote.js';
+
+export const DEFAULT_DEPLOY_BUILD_CONFIG_FILE = 'lzc-build.dev.yml';
+export const DEFAULT_RELEASE_BUILD_CONFIG_FILE = 'lzc-build.release.yml';
+
+function isFile(pathname) {
+	return fs.existsSync(pathname) && fs.statSync(pathname).isFile();
+}
+
+export function resolveBuildConfigPath(startDir = process.cwd(), buildConfigFile = DEFAULT_BUILD_CONFIG_FILE) {
+	const configName = String(buildConfigFile ?? DEFAULT_BUILD_CONFIG_FILE).trim() || DEFAULT_BUILD_CONFIG_FILE;
+	if (path.isAbsolute(configName)) {
+		return isFile(configName) ? configName : '';
+	}
+
+	const direct = path.resolve(startDir, configName);
+	if (isFile(direct)) {
+		return direct;
+	}
+
+	if (configName.includes('/') || configName.includes('\\')) {
+		return '';
+	}
+
+	let current = path.resolve(startDir);
+	while (true) {
+		const candidate = path.join(current, configName);
+		if (isFile(candidate)) {
+			return candidate;
+		}
+		const parent = path.dirname(current);
+		if (parent === current) {
+			break;
+		}
+		current = parent;
+	}
+	return '';
+}
+
+export function resolveProjectDeployConfigPath(startDir = process.cwd(), buildConfigFile = '') {
+	return resolvePreferredBuildConfigPath(startDir, buildConfigFile, DEFAULT_DEPLOY_BUILD_CONFIG_FILE);
+}
+
+export function resolveProjectReleaseConfigPath(startDir = process.cwd(), buildConfigFile = '') {
+	return resolvePreferredBuildConfigPath(startDir, buildConfigFile, DEFAULT_RELEASE_BUILD_CONFIG_FILE);
+}
+
+function resolvePreferredBuildConfigPath(startDir, buildConfigFile, preferredConfigFile) {
+	const explicitConfig = String(buildConfigFile ?? '').trim();
+	if (explicitConfig) {
+		const explicitPath = resolveBuildConfigPath(startDir, explicitConfig);
+		if (!explicitPath) {
+			throw new Error(`Build config file not found: ${explicitConfig}`);
+		}
+		return explicitPath;
+	}
+
+	const preferredConfigPath = resolveBuildConfigPath(startDir, preferredConfigFile);
+	if (preferredConfigPath) {
+		return preferredConfigPath;
+	}
+
+	const defaultConfigPath = resolveBuildConfigPath(startDir, DEFAULT_BUILD_CONFIG_FILE);
+	if (!defaultConfigPath) {
+		throw new Error(`Build config file not found: ${preferredConfigFile} or ${DEFAULT_BUILD_CONFIG_FILE}`);
+	}
+	return defaultConfigPath;
+}
+
+export async function resolveProjectRuntime(startDir = process.cwd(), buildConfigFile = DEFAULT_BUILD_CONFIG_FILE) {
+	const configPath = resolveBuildConfigPath(startDir, buildConfigFile);
+	if (!configPath) {
+		throw new Error(`Build config file not found: ${buildConfigFile}`);
+	}
+
+	const projectCwd = path.dirname(configPath);
+	const configName = path.basename(configPath);
+
+	const buildRemote = resolveBuildRemoteFromFile(projectCwd, configName);
+	if (!buildRemote) {
+		await shellApi.init();
+	}
+
+	const lpkBuild = await new LpkBuild(projectCwd, configName).init();
+	const manifest = await lpkBuild.getManifest();
+	const pkgId = String(manifest?.package ?? '').trim();
+	if (!pkgId) {
+		throw new Error('Manifest package is empty');
+	}
+
+	const bridge = new DebugBridge(projectCwd, buildRemote);
+	await bridge.init();
+
+	const userApp = isUserApp(manifest);
+	const composeProjectName = pkgId.replaceAll('.', '');
+	const localVersion = String(manifest?.version ?? '').trim();
+
+	return {
+		projectCwd,
+		configName,
+		configPath,
+		manifest,
+		pkgId,
+		userApp,
+		bridge,
+		composeProjectName,
+		localVersion,
+	};
+}
+
+function firstNonEmptyLine(text) {
+	return String(text ?? '')
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.find((line) => line.length > 0);
+}
+
+function parseComposeProjectList(raw) {
+	const text = String(raw ?? '').trim();
+	if (!text) {
+		return [];
+	}
+	try {
+		const parsed = JSON.parse(text);
+		if (!Array.isArray(parsed)) {
+			return [];
+		}
+		return parsed
+			.map((item) => ({
+				name: String(item?.Name ?? '').trim(),
+				status: String(item?.Status ?? '').trim(),
+				configFiles: String(item?.ConfigFiles ?? '').trim(),
+			}))
+			.filter((item) => item.name.length > 0);
+	} catch {
+		return [];
+	}
+}
+
+export async function listComposeProjects(runtime) {
+	try {
+		const output = await runtime.bridge.lzcDockerComposeCapture(['ls', '--format', 'json']);
+		return parseComposeProjectList(output);
+	} catch {
+		return [];
+	}
+}
+
+export async function getComposeProject(runtime) {
+	const projects = await listComposeProjects(runtime);
+	return projects.find((item) => item.name === runtime.composeProjectName) || null;
+}
+
+export async function getProjectDeployInfo(runtime) {
+	const remoteInfo = await runtime.bridge.info(runtime.pkgId);
+	const deployId = String(remoteInfo?.deploy_id ?? '').trim();
+	const deployedVersion = String(remoteInfo?.version ?? '').trim();
+	const domain = String(remoteInfo?.domain ?? '').trim();
+	const appStatus = String(remoteInfo?.status ?? '').trim();
+	const instanceStatus = String(remoteInfo?.instance_status ?? '').trim();
+	const errorReason = String(remoteInfo?.error_reason ?? '').trim();
+	const deployed = appStatus !== '' && appStatus !== 'NotInstalled';
+	const currentVersionDeployed = deployed && runtime.localVersion !== '' && deployedVersion === runtime.localVersion;
+	return {
+		...remoteInfo,
+		deployId,
+		localVersion: runtime.localVersion,
+		deployedVersion,
+		domain,
+		appStatus,
+		instanceStatus,
+		errorReason,
+		deployed,
+		currentVersionDeployed,
+		isRunning: instanceStatus === 'Status_Running',
+	};
+}
+
+export async function getProjectErrmsgByDeployId(runtime, deployId) {
+	const targetDeployId = String(deployId ?? '').trim();
+	if (!targetDeployId) {
+		return '';
+	}
+	try {
+		const errmsgPath = `/data/system/pkgm/run/${targetDeployId}/errmsg`;
+		const raw = await runtime.bridge.hostReadFile(errmsgPath);
+		return String(raw ?? '').trim();
+	} catch {
+		return '';
+	}
+}
+
+export async function ensureProjectRunning(runtime) {
+	const deploy = await getProjectDeployInfo(runtime);
+	if (!deploy.isRunning) {
+		throw new Error('Project app is not running. Run "lzc-cli project start" first.');
+	}
+	return deploy;
+}
+
+export async function getProjectComposePs(runtime) {
+	try {
+		return await runtime.bridge.lzcDockerComposeCapture(['-p', runtime.composeProjectName, 'ps']);
+	} catch {
+		return '';
+	}
+}
+
+export async function findProjectServiceContainer(runtime, service = 'app') {
+	const targetService = String(service || 'app');
+	try {
+		const output = await runtime.bridge.lzcDockerComposeCapture(['-p', runtime.composeProjectName, 'ps', '--status', 'running', '-q', targetService]);
+		return firstNonEmptyLine(output) || '';
+	} catch {
+		return '';
+	}
+}
+
+export async function ensureProjectServiceRunning(runtime, service = 'app') {
+	const targetService = String(service || 'app');
+	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 containerId = await findProjectServiceContainer(runtime, targetService);
+	if (!containerId) {
+		throw new Error(`Service \"${targetService}\" is not running. Run \"lzc-cli project start\" first.`);
+	}
+	return containerId;
+}
+
+export async function getProjectServiceEnv(runtime, service = 'app') {
+	const containerId = await ensureProjectServiceRunning(runtime, service);
+	const output = await runtime.bridge.lzcDockerCapture(['inspect', containerId]);
+	const inspectList = JSON.parse(String(output ?? '').trim());
+	if (!Array.isArray(inspectList) || inspectList.length === 0 || typeof inspectList[0] !== 'object' || !inspectList[0]) {
+		throw new Error(`Invalid inspect output for service "${String(service || 'app')}"`);
+	}
+	const envList = inspectList[0]?.Config?.Env;
+	if (!Array.isArray(envList)) {
+		throw new Error(`Invalid env list for service "${String(service || 'app')}"`);
+	}
+	const envMap = {};
+	for (const item of envList) {
+		const pair = String(item ?? '');
+		const idx = pair.indexOf('=');
+		if (idx <= 0) {
+			continue;
+		}
+		const key = pair.slice(0, idx);
+		const value = pair.slice(idx + 1);
+		envMap[key] = value;
+	}
+	return envMap;
+}

package/lib/app/project_start.js

@@ -0,0 +1,100 @@
+import logger from 'loglevel';
+import { DEFAULT_BUILD_CONFIG_FILE } from '../build_remote.js';
+import { LpkBuild } from './lpk_build.js';
+import { resolveProjectRuntime, getProjectDeployInfo, getProjectComposePs } from './project_runtime.js';
+
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitProjectRunning(runtime, timeoutMs = 90000) {
+	const startedAt = Date.now();
+	while (Date.now() - startedAt <= timeoutMs) {
+		const deploy = await getProjectDeployInfo(runtime);
+		if (deploy.isRunning) {
+			return deploy;
+		}
+		await sleep(1000);
+	}
+	return null;
+}
+
+async function waitProjectNotRunning(runtime, timeoutMs = 30000) {
+	const startedAt = Date.now();
+	while (Date.now() - startedAt <= timeoutMs) {
+		const deploy = await getProjectDeployInfo(runtime);
+		if (!deploy.isRunning) {
+			return deploy;
+		}
+		await sleep(1000);
+	}
+	return null;
+}
+
+async function deployCurrentVersion(runtime) {
+	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);
+}
+
+export function projectStartCommand() {
+	return {
+		command: 'start',
+		desc: 'Start project app',
+		builder: (args) => {
+			args.option('c', {
+				alias: 'config',
+				describe: 'Build config file name',
+				type: 'string',
+				default: DEFAULT_BUILD_CONFIG_FILE,
+			});
+			args.option('restart', {
+				describe: 'Force restart app instance',
+				type: 'boolean',
+				default: false,
+			});
+		},
+		handler: async ({ config, restart }) => {
+			const runtime = await resolveProjectRuntime(process.cwd(), config);
+			let deploy = await getProjectDeployInfo(runtime);
+
+			if (!deploy.currentVersionDeployed) {
+				logger.info('Current project version is not deployed. Build and install current version.');
+				await deployCurrentVersion(runtime);
+				deploy = await getProjectDeployInfo(runtime);
+			}
+
+			if (restart) {
+				if (deploy.isRunning) {
+					logger.info('Restart requested. Pause app instance first.');
+					await runtime.bridge.pause(runtime.pkgId);
+					deploy = await waitProjectNotRunning(runtime);
+					if (!deploy) {
+						throw new Error('Project app is still running after pause. Please check app status and try again.');
+					}
+				}
+				logger.info('Restart requested. Resume app instance.');
+				await runtime.bridge.resume(runtime.pkgId);
+			} else if (!deploy.isRunning) {
+				logger.info('App is not running. Resume app instance.');
+				await runtime.bridge.resume(runtime.pkgId);
+			}
+
+			deploy = await waitProjectRunning(runtime);
+			if (!deploy) {
+				throw new Error('Project app is still not running. Please check app status and try again.');
+			}
+
+			logger.info('Project app is running.');
+			const psOutput = await getProjectComposePs(runtime);
+			if (psOutput) {
+				console.log(psOutput);
+			}
+		},
+	};
+}

package/lib/box/index.js

@@ -1,7 +1,42 @@
 import logger from 'loglevel';
 import shellapi from '../shellapi.js';
-import { findSshPublicKey, selectSshPublicKey } from '../utils.js';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import { findSshPublicKey, selectSshPublicKey, isMacOs, isWindows } from '../utils.js';
 import { t } from '../i18n/index.js';
+import { addSSHBox, listSSHBoxes, getDefaultSSHBox, setDefaultSSHBox, clearDefaultSSHBox, removeSSHBox } from './ssh_remote.js';
+
+function getShellAPIConfigDir() {
+	const home = os.homedir();
+	let suffix = '/.config/hportal-client';
+	if (isMacOs) {
+		suffix = '/Library/Application Support/hportal-client';
+	} else if (isWindows) {
+		suffix = '\\AppData\\Roaming\\hportal-client';
+	}
+	return path.join(home, suffix);
+}
+
+function canUseShellApi() {
+	const configDir = getShellAPIConfigDir();
+	const addrFile = path.resolve(configDir, 'shellapi_addr');
+	const credFile = path.resolve(configDir, 'shellapi_cred');
+	return fs.existsSync(addrFile) && fs.existsSync(credFile);
+}
+
+async function fetchShellBoxes() {
+	if (!canUseShellApi()) {
+		return [];
+	}
+	try {
+		await shellapi.init();
+		return await shellapi.boxList();
+	} catch (error) {
+		logger.debug('query shell boxes failed', error);
+		return [];
+	}
+}
 
 export function boxCommand(box) {
 	let subCommands = [
@@ -9,14 +44,39 @@ export function boxCommand(box) {
 			command: 'switch <boxname>',
 			desc: t('lzc_cli.lib.box.index.switch_cmd_desc', '设置默认的盒子'),
 			handler: async ({ boxname }) => {
+				const target = String(boxname ?? '').trim();
+				if (!target) {
+					throw new Error('boxname is required');
+				}
+
+				const sshBoxes = listSSHBoxes();
+				if (sshBoxes.some((item) => item.box_name === target)) {
+					setDefaultSSHBox(target);
+					logger.info(`Default box switched: ${target}`);
+					return;
+				}
+
+				if (!canUseShellApi()) {
+					throw new Error(`Box "${target}" not found in SSH boxes and shellapi is unavailable`);
+				}
 				await shellapi.init();
-				await shellapi.setDefaultBox(boxname);
+				await shellapi.setDefaultBox(target);
+				clearDefaultSSHBox();
+				logger.info(`Default box switched: ${target}`);
 			},
 		},
 		{
 			command: 'default',
 			desc: t('lzc_cli.lib.box.index.default_cmd_desc', '输出当前默认的盒子名'),
 			handler: async () => {
+				const sshDefault = getDefaultSSHBox();
+				if (sshDefault) {
+					console.log(sshDefault.box_name);
+					return;
+				}
+				if (!canUseShellApi()) {
+					throw new Error('Default box not found. Run "lzc-cli box add-by-ssh <loginUser> <address>" first.');
+				}
 				await shellapi.init();
 				console.log(shellapi.boxname);
 			},
@@ -32,8 +92,17 @@ export function boxCommand(box) {
 				});
 			},
 			handler: async ({ verbose }) => {
-				await shellapi.init();
-				const boxes = await shellapi.boxList();
+				const shellBoxes = await fetchShellBoxes();
+				const sshBoxes = listSSHBoxes();
+				const sshDefault = sshBoxes.find((item) => item.is_default_box);
+				const boxes = [
+					...shellBoxes.map((item) => ({
+						...item,
+						is_default_box: sshDefault ? false : item.is_default_box,
+						box_type: 'hclient',
+					})),
+					...sshBoxes,
+				];
 				if (boxes.length === 0) {
 					console.log(t('lzc_cli.lib.box.index.list_cmd_box_not_exist_tips', '没有找到任何盒子，赶紧添加一个吧！'));
 					return;
@@ -45,6 +114,7 @@ export function boxCommand(box) {
 
 				const list = boxes.map((b) => {
 					const info = {};
+					info[`${t('lzc_cli.lib.box.index.list_cmd_table_box_type', 'Type')}`] = b.box_type ?? 'hclient';
 					info[`${t('lzc_cli.lib.box.index.list_cmd_table_box_name', '名称')}`] = b.box_name;
 					info[`${t('lzc_cli.lib.box.index.list_cmd_table_status', '状态')}`] = b.status;
 					info[`${t('lzc_cli.lib.box.index.list_cmd_table_login_user', '登录用户')}`] = b.login_user;
@@ -59,6 +129,9 @@ export function boxCommand(box) {
 			command: 'add-public-key',
 			desc: t('lzc_cli.lib.box.index.add_public_key_cmd_desc', '添加public-key到开发者工具中'),
 			handler: async () => {
+				if (!canUseShellApi()) {
+					throw new Error('add-public-key requires shellapi connection');
+				}
 				await shellapi.init();
 				const keys = await findSshPublicKey();
 				const sshInfo = await selectSshPublicKey(keys);
@@ -75,6 +148,30 @@ export function boxCommand(box) {
 				);
 			},
 		},
+		{
+			command: 'add-by-ssh <loginUser> <address>',
+			desc: t('lzc_cli.lib.box.index.add_by_ssh_cmd_desc', '通过 ssh 配置远端直连目标'),
+			handler: async ({ loginUser, address }) => {
+				const remote = addSSHBox(loginUser, address);
+				logger.info(`SSH box added: ${remote.box_name} (${remote.ssh_target})`);
+			},
+		},
+		{
+			command: 'del <boxname>',
+			aliases: ['delete', 'rm', 'remove'],
+			desc: 'Delete ssh box config by name',
+			handler: async ({ boxname }) => {
+				const target = String(boxname ?? '').trim();
+				if (!target) {
+					throw new Error('boxname is required');
+				}
+				const removed = removeSSHBox(target);
+				if (!removed) {
+					throw new Error(`SSH box not found: ${target}`);
+				}
+				logger.info(`SSH box deleted: ${target}`);
+			},
+		},
 	];
 	box.command({
 		command: 'box',