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

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);
@@ -68,13 +141,37 @@ export function boxCommand(box) {
 					t(
 						'lzc_cli.lib.box.index.add_public_key_cmd_apply_tips',
 						`请点击下面的连接，或者复制到浏览器中打开，点击申请完成添加
--> https://dev.{{boxname}}.heiyu.space/auth?key={{pk}}
+-> https://dev.{{ boxname }}.heiyu.space/auth?key={{ pk }}
 `,
-						{ boxname: shellapi.boxname, pk: pk },
+						{ boxname: shellapi.boxname, pk: pk, interpolation: { escapeValue: false } },
 					),
 				);
 			},
 		},
+		{
+			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',

package/lib/box/ssh_remote.js

@@ -0,0 +1,259 @@
+import env from '../config/env.js';
+
+const SSH_BOXES_KEY = 'ssh_boxes';
+const SSH_DEFAULT_BOX_KEY = 'default_ssh_box';
+const DEFAULT_SSH_PORT = 22;
+
+function parsePort(rawPort, source) {
+	if (rawPort === undefined || rawPort === null || rawPort === '') {
+		return DEFAULT_SSH_PORT;
+	}
+	const port = Number.parseInt(String(rawPort), 10);
+	if (!Number.isInteger(port) || port < 1 || port > 65535) {
+		throw new Error(`Invalid ssh port in ${source}: ${rawPort}`);
+	}
+	return port;
+}
+
+function normalizeLoginUser(loginUser) {
+	const user = String(loginUser ?? '').trim();
+	if (!user) {
+		throw new Error('loginUser is required');
+	}
+	return user;
+}
+
+function parseAddress(address) {
+	const value = String(address ?? '').trim();
+	if (!value) {
+		throw new Error('address is required');
+	}
+
+	if (value.startsWith('[')) {
+		const end = value.indexOf(']');
+		if (end <= 1) {
+			throw new Error(`Invalid address: ${address}`);
+		}
+		const host = value.slice(1, end).trim();
+		if (!host) {
+			throw new Error(`Invalid address: ${address}`);
+		}
+		const suffix = value.slice(end + 1).trim();
+		if (!suffix) {
+			return { sshHost: host, sshPort: DEFAULT_SSH_PORT };
+		}
+		if (!suffix.startsWith(':')) {
+			throw new Error(`Invalid address: ${address}`);
+		}
+		return { sshHost: host, sshPort: parsePort(suffix.slice(1), `address ${address}`) };
+	}
+
+	const colonCount = (value.match(/:/g) ?? []).length;
+	if (colonCount === 1) {
+		const splitIndex = value.lastIndexOf(':');
+		const host = value.slice(0, splitIndex).trim();
+		const port = value.slice(splitIndex + 1).trim();
+		if (!host) {
+			throw new Error(`Invalid address: ${address}`);
+		}
+		return { sshHost: host, sshPort: parsePort(port, `address ${address}`) };
+	}
+
+	if (colonCount > 1) {
+		return { sshHost: value, sshPort: DEFAULT_SSH_PORT };
+	}
+
+	return { sshHost: value, sshPort: DEFAULT_SSH_PORT };
+}
+
+function toBoxName(sshHost, sshPort) {
+	if (sshPort === DEFAULT_SSH_PORT) {
+		return sshHost;
+	}
+	return `${sshHost}:${sshPort}`;
+}
+
+function normalizeStoredBox(rawBox) {
+	if (!rawBox || typeof rawBox !== 'object') {
+		return null;
+	}
+	const loginUser = String(rawBox.login_user ?? '').trim();
+	const sshHost = String(rawBox.ssh_host ?? '').trim();
+	let sshPort;
+	try {
+		sshPort = parsePort(rawBox.ssh_port, 'saved ssh box');
+	} catch {
+		return null;
+	}
+	const boxName = String(rawBox.box_name ?? '').trim() || toBoxName(sshHost, sshPort);
+	if (!loginUser || !sshHost || !boxName) {
+		return null;
+	}
+	return {
+		box_name: boxName,
+		login_user: loginUser,
+		ssh_host: sshHost,
+		ssh_port: sshPort,
+	};
+}
+
+function readStoredBoxes() {
+	const rawBoxes = env.get(SSH_BOXES_KEY);
+	if (!Array.isArray(rawBoxes)) {
+		return [];
+	}
+	const result = [];
+	const indexByName = new Map();
+	for (const rawBox of rawBoxes) {
+		const box = normalizeStoredBox(rawBox);
+		if (!box) {
+			continue;
+		}
+		if (indexByName.has(box.box_name)) {
+			const index = indexByName.get(box.box_name);
+			result[index] = box;
+			continue;
+		}
+		indexByName.set(box.box_name, result.length);
+		result.push(box);
+	}
+	return result;
+}
+
+function saveStoredBoxes(boxes) {
+	env.set({
+		[SSH_BOXES_KEY]: boxes,
+	});
+}
+
+function readDefaultBoxName() {
+	return String(env.get(SSH_DEFAULT_BOX_KEY) ?? '').trim();
+}
+
+function saveDefaultBoxName(boxname) {
+	const name = String(boxname ?? '').trim();
+	if (!name) {
+		env.del(SSH_DEFAULT_BOX_KEY);
+		return;
+	}
+	env.set({
+		[SSH_DEFAULT_BOX_KEY]: name,
+	});
+}
+
+function resolveDefaultBoxName(storedBoxes) {
+	const currentDefault = readDefaultBoxName();
+	if (currentDefault && storedBoxes.some((item) => item.box_name === currentDefault)) {
+		return currentDefault;
+	}
+	return '';
+}
+
+function toPublicBox(stored, defaultName) {
+	const sshTarget = `${stored.login_user}@${stored.ssh_host}`;
+	return {
+		id: `ssh:${stored.box_name}`,
+		box_name: stored.box_name,
+		status: 'ssh',
+		login_user: stored.login_user,
+		is_admin_login: true,
+		is_default_box: stored.box_name === defaultName,
+		box_type: 'ssh',
+		ssh_host: stored.ssh_host,
+		ssh_port: stored.ssh_port,
+		ssh_target: sshTarget,
+	};
+}
+
+function toBuildRemote(box) {
+	return {
+		mode: 'build-remote',
+		source: `box:ssh:${box.box_name}`,
+		boxname: box.box_name,
+		sshUser: box.login_user,
+		sshHost: box.ssh_host,
+		sshPort: box.ssh_port,
+		sshTarget: box.ssh_target,
+	};
+}
+
+export function listSSHBoxes() {
+	const storedBoxes = readStoredBoxes();
+	const defaultName = resolveDefaultBoxName(storedBoxes);
+	return storedBoxes.map((item) => toPublicBox(item, defaultName));
+}
+
+export function addSSHBox(loginUser, address) {
+	const sshUser = normalizeLoginUser(loginUser);
+	const { sshHost, sshPort } = parseAddress(address);
+	const boxName = toBoxName(sshHost, sshPort);
+	const nextBox = normalizeStoredBox({
+		box_name: boxName,
+		login_user: sshUser,
+		ssh_host: sshHost,
+		ssh_port: sshPort,
+	});
+	if (!nextBox) {
+		throw new Error(`Invalid ssh box config: ${loginUser}@${address}`);
+	}
+
+	const savedBoxes = readStoredBoxes().filter((item) => item.box_name !== boxName);
+	savedBoxes.push(nextBox);
+	saveStoredBoxes(savedBoxes);
+	saveDefaultBoxName(boxName);
+
+	return toPublicBox(nextBox, boxName);
+}
+
+export function saveBuildRemoteBySSH(loginUser, address) {
+	return addSSHBox(loginUser, address);
+}
+
+export function getDefaultSSHBox() {
+	const boxes = listSSHBoxes();
+	const selected = boxes.find((item) => item.is_default_box);
+	return selected ?? null;
+}
+
+export function setDefaultSSHBox(boxname) {
+	const target = String(boxname ?? '').trim();
+	if (!target) {
+		throw new Error('boxname is required');
+	}
+	const exists = listSSHBoxes().some((item) => item.box_name === target);
+	if (!exists) {
+		throw new Error(`SSH box not found: ${target}`);
+	}
+	saveDefaultBoxName(target);
+}
+
+export function clearDefaultSSHBox() {
+	saveDefaultBoxName('');
+}
+
+export function removeSSHBox(boxname) {
+	const target = String(boxname ?? '').trim();
+	if (!target) {
+		throw new Error('boxname is required');
+	}
+	const storedBoxes = readStoredBoxes();
+	const exists = storedBoxes.some((item) => item.box_name === target);
+	if (!exists) {
+		return false;
+	}
+
+	const nextBoxes = storedBoxes.filter((item) => item.box_name !== target);
+	saveStoredBoxes(nextBoxes);
+	if (readDefaultBoxName() === target) {
+		saveDefaultBoxName('');
+	}
+	return true;
+}
+
+export function loadBuildRemoteFromConfig() {
+	const box = getDefaultSSHBox();
+	if (!box) {
+		return null;
+	}
+	return toBuildRemote(box);
+}

package/lib/build_remote.js

@@ -0,0 +1,22 @@
+import { loadBuildRemoteFromConfig } from './box/ssh_remote.js';
+
+export const DEFAULT_BUILD_CONFIG_FILE = 'lzc-build.yml';
+export const DEFAULT_BUILD_BASE_FILE = 'lzc-build.base.yml';
+
+export function resolveBuildRemoteFromOptions(options, source = DEFAULT_BUILD_CONFIG_FILE) {
+	void options;
+	void source;
+	return loadBuildRemoteFromConfig();
+}
+
+export function resolveBuildRemoteFromFile(startDir = process.cwd(), buildConfigFile = DEFAULT_BUILD_CONFIG_FILE) {
+	void startDir;
+	void buildConfigFile;
+	return loadBuildRemoteFromConfig();
+}
+
+export function hasBuildRemote(startDir = process.cwd(), buildConfigFile = DEFAULT_BUILD_CONFIG_FILE) {
+	void startDir;
+	void buildConfigFile;
+	return !!loadBuildRemoteFromConfig();
+}

package/lib/config/index.js

@@ -14,8 +14,9 @@ export function configCommand(program) {
 				const pair = Object.fromEntries([[key, value]]);
 				env.set(pair);
 				logger.info(
-					t('lzc_cli.lib.config.index.set_cmd_success_tips', `{{key}} 配置成功!`, {
+					t('lzc_cli.lib.config.index.set_cmd_success_tips', `{{ key }} 配置成功!`, {
 						key,
+						interpolation: { escapeValue: false }
 					}),
 				);
 			},
@@ -26,7 +27,7 @@ export function configCommand(program) {
 			handler: async ({ key }) => {
 				if (key) {
 					env.del(key);
-					logger.info(t('lzc_cli.lib.config.index.del_cmd_success', `删除 {{key}} 成功!`, { key }));
+					logger.info(t('lzc_cli.lib.config.index.del_cmd_success', `删除 {{ key }} 成功!`, { key, interpolation: { escapeValue: false } }));
 					return;
 				}
 			},
@@ -50,7 +51,7 @@ export function configCommand(program) {
 	];
 	program.command({
 		command: 'config',
-		desc: t('lzc_cli.lib.config.index.config_cmd_desc', '配置管理'),
+		desc: false,
 		builder: (args) => {
 			args.command(subCommands);
 			args.example('$0 config get', t('lzc_cli.lib.config.index.config_cmd_list_tips', '列出所有配置'))