@lazycatcloud/lzc-cli 2.0.0-pre.8 → 2.0.0-pre.9

package/README.md

@@ -94,6 +94,6 @@ lzc-cli box add-by-ssh root 192.168.31.13
 
 1. 参数格式为 `loginUser address`，地址支持 `host` 或 `host:port`
 2. 配置后会自动设为默认盒子，可通过 `box list/switch/default` 管理
-3. `project release/deploy/start/exec/cp/log/info`、`lpk install/uninstall`、`docker/docker-compose` 都会优先使用该远端
+3. `project release/deploy/start/exec/cp/log/info/sync`、`lpk install/uninstall`、`docker/docker-compose` 都会优先使用该远端
 4. `lzc-build.yml` 不再支持 `remote` 字段
 5. 可选基础配置文件为 `lzc-build.base.yml`（与构建配置同目录）

package/changelog.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [2.0.0-pre.9](https://gitee.com/linakesi/lzc-cli/compare/v2.0.0-pre.8...v2.0.0-pre.9) (2026-03-30)
+
+### Features
+
+- project sync support ssh box
+
 ## [2.0.0-pre.8](https://gitee.com/linakesi/lzc-cli/compare/v2.0.0-pre.7...v2.0.0-pre.8) (2026-03-27)
 
 ### Bug Fixes

package/lib/app/project_sync.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import net from 'node:net';
 import path from 'node:path';
 import chokidar from 'chokidar';
 import debounce from 'lodash.debounce';
@@ -6,12 +7,15 @@ import ignore from 'ignore';
 import spawn from 'cross-spawn';
 import logger from 'loglevel';
 import { checkRsync, contextDirname, isDebugMode, isWindows, resolveDomain } from '../utils.js';
+import { sshBinary } from '../debug_bridge.js';
 import { addProjectTargetOptions, resolveProjectRuntime, getProjectDeployInfo } from './project_runtime.js';
 
 export const DEFAULT_PROJECT_SYNC_TARGET = '/lzcapp/cache/project-mirror';
+const DEBUG_BRIDGE_CONTAINER = 'cloudlazycatdevelopertools-app-1';
 const PROJECT_SYNC_CACHE_ROOT = '/lzcapp/cache';
 const RSYNC_PASSWORD = 'fakefakefake';
 const RSYNC_PORT = '874';
+const LOCALHOST = '127.0.0.1';
 const LZCDEVIGNORE_FILE = '.lzcdevignore';
 const GITIGNORE_FILE = '.gitignore';
 const DEFAULT_LZCDEVIGNORE_RULES = [
@@ -125,11 +129,8 @@ function formatRsyncHost(host) {
 	return String(host).includes(':') ? `[${host}]` : String(host);
 }
 
-async function resolveRsyncHost(runtime) {
-	if (runtime.bridge.isBuildRemoteMode()) {
-		return runtime.bridge.buildRemote.sshHost;
-	}
-	return resolveDomain(runtime.bridge.domain);
+function formatSshForwardHost(host) {
+	return String(host).includes(':') ? `[${host}]` : String(host);
 }
 
 async function resolveRsyncUID(runtime) {
@@ -148,7 +149,26 @@ function buildRsyncModulePath(runtime, uid, targetDir) {
 	return modulePath;
 }
 
-export function buildRsyncArgs(runtime, uid, host, rootDir, targetDir, sourceDir, deleteMode, dryRun) {
+async function ensureBuildRemoteSyncTarget(runtime, uid, targetDir) {
+	if (!runtime.bridge.isBuildRemoteMode()) {
+		return;
+	}
+	const modulePath = buildRsyncModulePath(runtime, uid, targetDir);
+	const result = runtime.bridge.remoteHostExec([
+		'lzc-docker',
+		'exec',
+		'-i',
+		DEBUG_BRIDGE_CONTAINER,
+		'mkdir',
+		'-p',
+		`/lzcapp/run/data/app/cache/${modulePath}`,
+	]);
+	if (result.status !== 0) {
+		throw new Error(String(result.stderr ?? result.stdout ?? '').trim() || 'prepare remote sync target failed');
+	}
+}
+
+export function buildRsyncArgs(runtime, uid, host, rootDir, targetDir, sourceDir, deleteMode, dryRun, port = RSYNC_PORT) {
 	const args = ['--recursive', '--links', '--times', '--perms', '--omit-dir-times', '--human-readable', '--itemize-changes', '--compress'];
 	if (isDebugMode()) {
 		args.push('-P');
@@ -167,12 +187,33 @@ export function buildRsyncArgs(runtime, uid, host, rootDir, targetDir, sourceDir
 		args.push('--relative');
 	}
 	const modulePath = buildRsyncModulePath(runtime, uid, targetDir);
-	const dest = `rsync://${uid}@${formatRsyncHost(host)}:${RSYNC_PORT}/lzcapp_cache/${modulePath}/`;
+	const dest = `rsync://${uid}@${formatRsyncHost(host)}:${port}/lzcapp_cache/${modulePath}/`;
 	const sourceArg = sourceDir ? `./${sourceDir}/` : './';
 	args.push(sourceArg, dest);
 	return args;
 }
 
+export function buildBuildRemoteRsyncTunnelArgs(runtime, localPort, rsyncTargetHost) {
+	const remoteArgs = runtime.bridge.remoteSshArgsRaw();
+	const sshTarget = remoteArgs.at(-1);
+	if (!sshTarget) {
+		throw new Error('build remote ssh target is empty');
+	}
+	const formattedTargetHost = formatSshForwardHost(rsyncTargetHost);
+	if (!formattedTargetHost) {
+		throw new Error('build remote rsync target host is empty');
+	}
+	return [
+		...remoteArgs.slice(0, -1),
+		'-o',
+		'ExitOnForwardFailure=yes',
+		'-L',
+		`${LOCALHOST}:${localPort}:${formattedTargetHost}:${RSYNC_PORT}`,
+		sshTarget,
+		'-N',
+	];
+}
+
 function formatRsyncLine(line, dryRun) {
 	const text = String(line ?? '').trim();
 	if (!text) {
@@ -250,6 +291,161 @@ function runRsyncProcess(command, args, cwd, dryRun) {
 	});
 }
 
+function reserveLocalPort() {
+	return new Promise((resolve, reject) => {
+		const server = net.createServer();
+		server.once('error', reject);
+		server.listen(0, LOCALHOST, () => {
+			const address = server.address();
+			if (!address || typeof address === 'string') {
+				server.close(() => reject(new Error('reserve local port failed')));
+				return;
+			}
+			server.close((error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve(address.port);
+			});
+		});
+	});
+}
+
+function waitForTunnelReady(child, host, port, stderrLines) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let timer = null;
+		let closeHandler = null;
+		let errorHandler = null;
+		const deadline = Date.now() + 5000;
+
+		const finish = (callback) => {
+			if (settled) {
+				return;
+			}
+			settled = true;
+			if (timer) {
+				clearTimeout(timer);
+			}
+			if (closeHandler) {
+				child.off('close', closeHandler);
+			}
+			if (errorHandler) {
+				child.off('error', errorHandler);
+			}
+			callback();
+		};
+
+		const retry = () => {
+			if (settled) {
+				return;
+			}
+			if (child.exitCode !== null) {
+				const detail = stderrLines.join('\n').trim();
+				finish(() => reject(new Error(detail || 'ssh tunnel exited before ready')));
+				return;
+			}
+			const socket = net.createConnection({ host, port });
+			socket.once('connect', () => {
+				socket.destroy();
+				finish(() => resolve());
+			});
+			socket.once('error', () => {
+				socket.destroy();
+				if (Date.now() >= deadline) {
+					const detail = stderrLines.join('\n').trim();
+					finish(() => reject(new Error(detail || 'ssh tunnel ready timeout')));
+					return;
+				}
+				timer = setTimeout(retry, 50);
+			});
+		};
+
+		closeHandler = () => {
+			const detail = stderrLines.join('\n').trim();
+			finish(() => reject(new Error(detail || 'ssh tunnel exited before ready')));
+		};
+		errorHandler = (error) => {
+			const detail = stderrLines.join('\n').trim();
+			finish(() => reject(new Error(detail || error.message || 'ssh tunnel start failed')));
+		};
+		child.once('close', closeHandler);
+		child.once('error', errorHandler);
+		retry();
+	});
+}
+
+function closeTunnel(child) {
+	return new Promise((resolve) => {
+		if (!child || child.exitCode !== null) {
+			resolve();
+			return;
+		}
+		const forceTimer = setTimeout(() => {
+			if (child.exitCode === null) {
+				child.kill('SIGKILL');
+			}
+		}, 1000);
+		child.once('close', () => {
+			clearTimeout(forceTimer);
+			resolve();
+		});
+		child.kill('SIGTERM');
+	});
+}
+
+async function createBuildRemoteRsyncTransport(runtime) {
+	const inspect = runtime.bridge.remoteHostExec([
+		'lzc-docker',
+		'inspect',
+		'-f',
+		'{{range.NetworkSettings.Networks}}{{.IPAddress}}{{end}}',
+		DEBUG_BRIDGE_CONTAINER,
+	]);
+	if (inspect.status !== 0) {
+		throw new Error(String(inspect.stderr ?? inspect.stdout ?? '').trim() || 'resolve debug bridge container ip failed');
+	}
+	const rsyncTargetHost = String(inspect.stdout ?? '').trim();
+	if (!rsyncTargetHost) {
+		throw new Error('debug bridge container ip is empty');
+	}
+	const localPort = await reserveLocalPort();
+	const stderrLines = [];
+	const child = spawn(sshBinary(), buildBuildRemoteRsyncTunnelArgs(runtime, localPort, rsyncTargetHost), {
+		shell: false,
+		stdio: ['ignore', 'ignore', 'pipe'],
+	});
+	child.stderr?.on('data', (chunk) => {
+		const text = String(chunk ?? '').trim();
+		if (text) {
+			stderrLines.push(text);
+		}
+	});
+	try {
+		await waitForTunnelReady(child, LOCALHOST, localPort, stderrLines);
+		return {
+			host: LOCALHOST,
+			port: String(localPort),
+			close: async () => closeTunnel(child),
+		};
+	} catch (error) {
+		await closeTunnel(child);
+		throw error;
+	}
+}
+
+async function createRsyncTransport(runtime) {
+	if (runtime.bridge.isBuildRemoteMode()) {
+		return createBuildRemoteRsyncTransport(runtime);
+	}
+	return {
+		host: await resolveDomain(runtime.bridge.domain),
+		port: RSYNC_PORT,
+		close: async () => {},
+	};
+}
+
 async function ensureProjectDeployed(runtime) {
 	const deploy = await getProjectDeployInfo(runtime);
 	if (!deploy.deployed) {
@@ -305,27 +501,28 @@ function collectWatchChange(state, eventName, relPath, deleteEnabled) {
 	}
 }
 
-async function runSyncPath(runtime, rootDir, options, sourceDir, deleteMode) {
-	const [uid, host] = await Promise.all([resolveRsyncUID(runtime), resolveRsyncHost(runtime)]);
+async function runSyncPath(runtime, transport, rootDir, options, sourceDir, deleteMode) {
+	const uid = await resolveRsyncUID(runtime);
+	await ensureBuildRemoteSyncTarget(runtime, uid, options.target);
 	const rsyncCmd = resolveRsyncCommand();
-	const rsyncArgs = buildRsyncArgs(runtime, uid, host, rootDir, options.target, sourceDir, deleteMode, options.dryRun);
+	const rsyncArgs = buildRsyncArgs(runtime, uid, transport.host, rootDir, options.target, sourceDir, deleteMode, options.dryRun, transport.port);
 	logger.debug('project sync rsync:', rsyncCmd, rsyncArgs.join(' '));
 	return runRsyncProcess(rsyncCmd, rsyncArgs, rootDir, options.dryRun);
 }
 
-async function runInitialSync(runtime, rootDir, options) {
+async function runInitialSync(runtime, transport, rootDir, options) {
 	await ensureProjectDeployed(runtime);
-	const hasChanges = await runSyncPath(runtime, rootDir, options, '', options.delete);
+	const hasChanges = await runSyncPath(runtime, transport, rootDir, options, '', options.delete);
 	if (!hasChanges) {
 		logger.info('project sync: no changes');
 	}
 }
 
-async function runDirtySync(runtime, rootDir, options, state) {
+async function runDirtySync(runtime, transport, rootDir, options, state) {
 	await ensureProjectDeployed(runtime);
 	if (state.fullSyncRequested) {
 		state.fullSyncRequested = false;
-		const hasChanges = await runSyncPath(runtime, rootDir, options, '', options.delete);
+		const hasChanges = await runSyncPath(runtime, transport, rootDir, options, '', options.delete);
 		if (!hasChanges) {
 			logger.info('project sync: no changes');
 		}
@@ -337,10 +534,10 @@ async function runDirtySync(runtime, rootDir, options, state) {
 	state.syncDirs.clear();
 	let hasChanges = false;
 	for (const dir of pendingDeleteDirs) {
-		hasChanges = (await runSyncPath(runtime, rootDir, options, dir, true)) || hasChanges;
+		hasChanges = (await runSyncPath(runtime, transport, rootDir, options, dir, true)) || hasChanges;
 	}
 	for (const dir of pendingSyncDirs) {
-		hasChanges = (await runSyncPath(runtime, rootDir, options, dir, false)) || hasChanges;
+		hasChanges = (await runSyncPath(runtime, transport, rootDir, options, dir, false)) || hasChanges;
 	}
 	if (!hasChanges && pendingDeleteDirs.length === 0 && pendingSyncDirs.length === 0) {
 		logger.info('project sync: no changes');
@@ -421,76 +618,81 @@ export function projectSyncCommand() {
 			resolveSyncCacheSubpath(options.target);
 			logger.info(`Sync root: ${rootDir}`);
 			logger.info(`Sync target: ${options.target}`);
+			const transport = await createRsyncTransport(runtime);
 
-			if (!watch) {
-				await runInitialSync(runtime, rootDir, options);
-				return;
-			}
-
-			let watcher = null;
-			let running = false;
-			let pending = false;
-			const triggerSync = async () => {
-				if (running) {
-					pending = true;
+			try {
+				if (!watch) {
+					await runInitialSync(runtime, transport, rootDir, options);
 					return;
 				}
-				running = true;
-				try {
-					await runDirtySync(runtime, rootDir, options, state);
-					if (state.reloadWatcherRequested) {
-						state.reloadWatcherRequested = false;
-						await watcher.close();
-						watcher = createWatcher();
-						await waitWatcherReady(watcher);
-						logger.info('project sync watch reloaded after .lzcdevignore change.');
+
+				let watcher = null;
+				let running = false;
+				let pending = false;
+				const triggerSync = async () => {
+					if (running) {
+						pending = true;
+						return;
 					}
-				} catch (error) {
-					logger.error(`project sync failed: ${error.message}`);
-				} finally {
-					running = false;
-					if (pending) {
-						pending = false;
-						await triggerSync();
+					running = true;
+					try {
+						await runDirtySync(runtime, transport, rootDir, options, state);
+						if (state.reloadWatcherRequested) {
+							state.reloadWatcherRequested = false;
+							await watcher.close();
+							watcher = createWatcher();
+							await waitWatcherReady(watcher);
+							logger.info('project sync watch reloaded after .lzcdevignore change.');
+						}
+					} catch (error) {
+						logger.error(`project sync failed: ${error.message}`);
+					} finally {
+						running = false;
+						if (pending) {
+							pending = false;
+							await triggerSync();
+						}
 					}
-				}
-			};
+				};
 
-			const debouncedTrigger = debounce(() => {
-				void triggerSync();
-			}, 300);
-
-			const createWatcher = () => {
-				const instance = chokidar.watch(rootDir, {
-					ignoreInitial: true,
-					ignored: createWatchIgnored(rootDir),
-					awaitWriteFinish: {
-						stabilityThreshold: 150,
-						pollInterval: 50,
-					},
-				});
-				attachWatchHandlers(instance, rootDir, options, state, debouncedTrigger);
-				return instance;
-			};
+				const debouncedTrigger = debounce(() => {
+					void triggerSync();
+				}, 300);
+
+				const createWatcher = () => {
+					const instance = chokidar.watch(rootDir, {
+						ignoreInitial: true,
+						ignored: createWatchIgnored(rootDir),
+						awaitWriteFinish: {
+							stabilityThreshold: 150,
+							pollInterval: 50,
+						},
+					});
+					attachWatchHandlers(instance, rootDir, options, state, debouncedTrigger);
+					return instance;
+				};
 
-			watcher = createWatcher();
-			await waitWatcherReady(watcher);
-			await runInitialSync(runtime, rootDir, options);
-			if (hasPendingChanges(state)) {
-				await runDirtySync(runtime, rootDir, options, state);
+				watcher = createWatcher();
+				await waitWatcherReady(watcher);
+				await runInitialSync(runtime, transport, rootDir, options);
+				if (hasPendingChanges(state)) {
+					await runDirtySync(runtime, transport, rootDir, options, state);
+				}
+				logger.info('project sync watch started. Press Ctrl+C to stop.');
+				await new Promise((resolve) => {
+					const shutdown = async () => {
+						debouncedTrigger.cancel();
+						if (watcher) {
+							await watcher.close();
+						}
+						resolve();
+					};
+					process.once('SIGINT', shutdown);
+					process.once('SIGTERM', shutdown);
+				});
+			} finally {
+				await transport.close();
 			}
-			logger.info('project sync watch started. Press Ctrl+C to stop.');
-			await new Promise((resolve) => {
-				const shutdown = async () => {
-					debouncedTrigger.cancel();
-					if (watcher) {
-						await watcher.close();
-					}
-					resolve();
-				};
-				process.once('SIGINT', shutdown);
-				process.once('SIGTERM', shutdown);
-			});
 		},
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lazycatcloud/lzc-cli",
-	"version": "2.0.0-pre.8",
+	"version": "2.0.0-pre.9",
 	"description": "lazycat cloud developer kit",
 	"scripts": {
 		"release": "release-it patch",