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

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

@@ -51,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', '列出所有配置'))