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

package/lib/app/manifest_build.js

@@ -0,0 +1,259 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const ENV_KEY_REGEXP = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const BUILD_DIRECTIVE_PREFIX = '#@build';
+
+function normalizeDirectiveValue(rawValue) {
+	const trimmed = String(rawValue ?? '').trim();
+	if (!trimmed) {
+		return '';
+	}
+	if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+		return trimmed.slice(1, -1);
+	}
+	return trimmed;
+}
+
+export function normalizeBuildEnvEntries(rawEnvs) {
+	if (rawEnvs === undefined || rawEnvs === null) {
+		return [];
+	}
+	if (!Array.isArray(rawEnvs)) {
+		throw new Error('envs must be a string array');
+	}
+	const normalized = [];
+	const seen = new Set();
+	for (let index = 0; index < rawEnvs.length; index += 1) {
+		const rawEntry = rawEnvs[index];
+		if (typeof rawEntry !== 'string') {
+			throw new Error(`envs[${index}] must be a string`);
+		}
+		const entry = rawEntry.trim();
+		if (!entry) {
+			throw new Error(`envs[${index}] must not be empty`);
+		}
+		const equalIndex = entry.indexOf('=');
+		if (equalIndex <= 0) {
+			throw new Error(`envs[${index}] must use KEY=VALUE format`);
+		}
+		const key = entry.slice(0, equalIndex).trim();
+		const value = entry.slice(equalIndex + 1);
+		if (!ENV_KEY_REGEXP.test(key)) {
+			throw new Error(`envs[${index}] has invalid key "${key}"`);
+		}
+		if (seen.has(key)) {
+			throw new Error(`envs contains duplicated key "${key}"`);
+		}
+		seen.add(key);
+		normalized.push(`${key}=${value}`);
+	}
+	return normalized;
+}
+
+export function buildVarsFromEnvEntries(rawEnvs) {
+	const envs = normalizeBuildEnvEntries(rawEnvs);
+	const result = {};
+	for (const entry of envs) {
+		const equalIndex = entry.indexOf('=');
+		const key = entry.slice(0, equalIndex);
+		const value = entry.slice(equalIndex + 1);
+		result[key] = value;
+	}
+	return result;
+}
+
+function parseBuildDirective(line) {
+	const trimmed = String(line ?? '').trim();
+	if (!trimmed.startsWith(BUILD_DIRECTIVE_PREFIX)) {
+		return null;
+	}
+	const body = trimmed.slice(BUILD_DIRECTIVE_PREFIX.length).trim();
+	if (!body) {
+		throw new Error('build directive is empty');
+	}
+	const spaceIndex = body.indexOf(' ');
+	const command = (spaceIndex >= 0 ? body.slice(0, spaceIndex) : body).trim();
+	const args = (spaceIndex >= 0 ? body.slice(spaceIndex + 1) : '').trim();
+	if (!command) {
+		throw new Error('build directive command is empty');
+	}
+	return {
+		command,
+		args,
+	};
+}
+
+function evaluateBuildCondition(expr, context) {
+	const normalized = String(expr ?? '').trim();
+	if (!normalized) {
+		throw new Error('build if condition is empty');
+	}
+
+	let match = normalized.match(/^profile\s*(==|=|!=)\s*(.+)$/);
+	if (match) {
+		const expected = normalizeDirectiveValue(match[2]);
+		const actual = String(context.profile ?? '');
+		return match[1] === '!=' ? actual !== expected : actual === expected;
+	}
+
+	match = normalized.match(/^env\.([A-Za-z_][A-Za-z0-9_]*)\s*(==|=|!=)\s*(.+)$/);
+	if (match) {
+		const key = match[1];
+		const expected = normalizeDirectiveValue(match[3]);
+		const actual = String(context.envs?.[key] ?? '');
+		return match[2] === '!=' ? actual !== expected : actual === expected;
+	}
+
+	match = normalized.match(/^env\.([A-Za-z_][A-Za-z0-9_]*)$/);
+	if (match) {
+		const key = match[1];
+		return String(context.envs?.[key] ?? '').trim() !== '';
+	}
+
+	throw new Error(`unsupported build condition "${normalized}"`);
+}
+
+function resolveIncludePath(rawPath, rootDir) {
+	const normalized = normalizeDirectiveValue(rawPath);
+	if (!normalized) {
+		throw new Error('build include path is empty');
+	}
+	if (path.isAbsolute(normalized)) {
+		return normalized;
+	}
+	return path.resolve(rootDir, normalized);
+}
+
+function formatSourceRef(filePath, lineNumber) {
+	return `${filePath}:${lineNumber}`;
+}
+
+function indentIncludedText(text, indent) {
+	if (!text) {
+		return '';
+	}
+	const prefix = String(indent ?? '');
+	return String(text)
+		.split('\n')
+		.map((line) => {
+			if (!line) {
+				return '';
+			}
+			return `${prefix}${line}`;
+		})
+		.join('\n');
+}
+
+function processManifestText(rawText, context, options) {
+	const filePath = options.filePath;
+	const rootDir = options.rootDir;
+	const allowDirectives = options.allowDirectives;
+	const lines = String(rawText ?? '').split('\n');
+	const output = [];
+	const stack = [{
+		type: 'root',
+		active: true,
+	}];
+
+	const currentActive = () => stack[stack.length - 1].active;
+
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		const directive = parseBuildDirective(line);
+		if (!directive) {
+			if (currentActive()) {
+				output.push(line);
+			}
+			continue;
+		}
+
+		if (!allowDirectives) {
+			throw new Error(`nested build directive is not allowed in included file at ${formatSourceRef(filePath, index + 1)}`);
+		}
+
+		switch (directive.command) {
+			case 'if': {
+				const parentActive = currentActive();
+				const condition = evaluateBuildCondition(directive.args, context);
+				stack.push({
+					type: 'if',
+					parentActive,
+					condition,
+					elseSeen: false,
+					active: parentActive && condition,
+				});
+				break;
+			}
+			case 'else': {
+				if (stack.length === 1 || stack[stack.length - 1].type !== 'if') {
+					throw new Error(`build else without matching if at ${formatSourceRef(filePath, index + 1)}`);
+				}
+				const top = stack[stack.length - 1];
+				if (top.elseSeen) {
+					throw new Error(`duplicate build else at ${formatSourceRef(filePath, index + 1)}`);
+				}
+				top.elseSeen = true;
+				top.active = top.parentActive && !top.condition;
+				break;
+			}
+			case 'end': {
+				if (stack.length === 1 || stack[stack.length - 1].type !== 'if') {
+					throw new Error(`build end without matching if at ${formatSourceRef(filePath, index + 1)}`);
+				}
+				stack.pop();
+				break;
+			}
+			case 'include': {
+				if (!currentActive()) {
+					break;
+				}
+				const lineIndent = line.match(/^\s*/)?.[0] ?? '';
+				const includePath = resolveIncludePath(directive.args, rootDir);
+				if (!fs.existsSync(includePath)) {
+					throw new Error(`build include file not found at ${formatSourceRef(filePath, index + 1)}: ${includePath}`);
+				}
+				const includedText = fs.readFileSync(includePath, 'utf8');
+				const rendered = processManifestText(includedText, context, {
+					filePath: includePath,
+					rootDir,
+					allowDirectives: false,
+				});
+				if (rendered.length > 0) {
+					output.push(indentIncludedText(rendered, lineIndent));
+				}
+				break;
+			}
+			default:
+				throw new Error(`unsupported build directive "${directive.command}" at ${formatSourceRef(filePath, index + 1)}`);
+		}
+	}
+
+	if (stack.length !== 1) {
+		throw new Error(`unclosed build if block in ${filePath}`);
+	}
+
+	return output.join('\n');
+}
+
+export function preprocessManifestText(rawText, context, options = {}) {
+	const filePath = options.filePath || '<manifest>';
+	const rootDir = options.rootDir || process.cwd();
+	return processManifestText(rawText, {
+		profile: String(context?.profile ?? '').trim(),
+		envs: { ...(context?.envs ?? {}) },
+	}, {
+		filePath,
+		rootDir,
+		allowDirectives: true,
+	});
+}
+
+export function preprocessManifestFile(manifestPath, context) {
+	const filePath = path.resolve(manifestPath);
+	const rawText = fs.readFileSync(filePath, 'utf8');
+	return preprocessManifestText(rawText, context, {
+		filePath,
+		rootDir: path.dirname(filePath),
+	});
+}

package/lib/app/project_cp.js

@@ -2,8 +2,7 @@ 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';
+import { addProjectTargetOptions, resolveProjectRuntime, ensureProjectServiceRunning } from './project_runtime.js';
 
 function normalizeSourcePath(source) {
 	const sourcePath = path.resolve(process.cwd(), String(source));
@@ -36,19 +35,15 @@ export function projectCpCommand() {
 				type: 'string',
 				default: 'app',
 			});
-			args.option('c', {
-				alias: 'config',
-				describe: 'Build config file name',
-				type: 'string',
-				default: DEFAULT_BUILD_CONFIG_FILE,
-			});
+			addProjectTargetOptions(args);
 		},
-		handler: async ({ src, dest, service, config }) => {
+		handler: async ({ src, dest, service, config, dev, release }) => {
 			if (String(dest).includes(':')) {
 				throw new Error('Destination path must not include service prefix');
 			}
 
-			const runtime = await resolveProjectRuntime(process.cwd(), config);
+			const runtime = await resolveProjectRuntime(process.cwd(), { config, dev, release, command: 'lzc-cli project cp' });
+			logger.info(`Build config: ${runtime.configPath}`);
 			const targetService = String(service || 'app');
 			const containerId = await ensureProjectServiceRunning(runtime, targetService);
 

package/lib/app/project_deploy.js

@@ -1,33 +1,102 @@
 import logger from 'loglevel';
 import { LpkBuild } from './lpk_build.js';
-import { resolveProjectRuntime, resolveProjectDeployConfigPath } from './project_runtime.js';
+import { printProjectInfo } from './project_info.js';
+import { addProjectTargetOptions, resolveProjectRuntime, resolveProjectDeployConfigPath, getProjectDeployInfo, getProjectErrmsgByDeployId } from './project_runtime.js';
+
+export function isAppContainerNotReadyError(error) {
+	const message = String(error?.message ?? error ?? '');
+	return message.includes('No such container') || message.includes('is not running');
+}
+
+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();
+}
+
+export function buildProjectStartupFailureMessage(deploy = {}, errmsg = '') {
+	const instanceStatus = String(deploy?.instanceStatus ?? '').trim() || '(unknown)';
+	const errorReason = String(deploy?.errorReason ?? '').trim();
+	const cleanedErrmsg = trimErrmsgByDockerConfigs(errmsg);
+	const details = [];
+	if (errorReason) {
+		details.push(`error reason: ${errorReason}`);
+	}
+	if (cleanedErrmsg) {
+		details.push(`error message:\n${cleanedErrmsg}`);
+	}
+	const suffix = details.length > 0 ? `\n${details.join('\n')}` : '';
+	return `Project app entered error state before dev.id sync. Instance status: ${instanceStatus}.${suffix}`;
+}
+
+async function detectProjectStartupFailure(runtime) {
+	const deploy = await getProjectDeployInfo(runtime);
+	const appStatus = String(deploy?.appStatus ?? '').trim();
+	const instanceStatus = String(deploy?.instanceStatus ?? '').trim();
+	const instanceStatusLower = instanceStatus.toLowerCase();
+	if (appStatus === 'NotInstalled') {
+		throw new Error('Project package is not installed after deploy. Please retry and run "lzc-cli project info" for details.');
+	}
+	if (!instanceStatusLower.includes('error')) {
+		return null;
+	}
+	const errmsg = await getProjectErrmsgByDeployId(runtime, deploy.deployId);
+	throw new Error(buildProjectStartupFailureMessage(deploy, errmsg));
+}
+
+async function syncProjectDevID(runtime, { waitForContainer = false } = {}) {
+	const devId = await runtime.bridge.resolveDevId();
+	logger.info(`Sync dev.id: ${devId || '<empty>'}`);
+	const maxAttempts = waitForContainer ? 30 : 1;
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+		try {
+			await runtime.bridge.syncDevID(runtime.pkgId, devId, runtime.userApp);
+			logger.info('dev id synced successfully.');
+			return;
+		} catch (error) {
+			if (!waitForContainer || !isAppContainerNotReadyError(error)) {
+				throw error;
+			}
+			await detectProjectStartupFailure(runtime);
+			if (attempt === maxAttempts) {
+				throw error;
+			}
+			if (attempt === 1) {
+				logger.info('Waiting for app container before syncing dev.id...');
+			}
+			await new Promise((resolve) => setTimeout(resolve, 1000));
+		}
+	}
+}
 
 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',
-			});
+			addProjectTargetOptions(args);
 		},
-		handler: async ({ config }) => {
-			const configPath = resolveProjectDeployConfigPath(process.cwd(), config);
+		handler: async ({ config, dev, release }) => {
+			const configPath = resolveProjectDeployConfigPath(process.cwd(), { config, dev, release, command: 'lzc-cli project deploy' });
 			const runtime = await resolveProjectRuntime(process.cwd(), configPath);
-			logger.info(`Deploy config: ${runtime.configPath}`);
+			logger.info(`Build config: ${runtime.configPath}`);
 
-			const lpkBuild = await new LpkBuild(runtime.projectCwd, runtime.configName).init();
+			const lpkBuild = await new LpkBuild(runtime.projectCwd, runtime.configName, { forceV2: true }).init();
 			lpkBuild.onBeforeBuildPackage(async (options) => {
-				delete options['devshell'];
+				delete options.devshell;
 				return options;
 			});
 			const pkgPath = await lpkBuild.exec();
 
 			logger.info(`Install package: ${pkgPath}`);
 			await runtime.bridge.install(pkgPath, runtime.pkgId);
+			await syncProjectDevID(runtime, { waitForContainer: true });
 			logger.info('Project deployed successfully.');
+			await printProjectInfo(runtime);
 		},
 	};
 }

package/lib/app/project_exec.js

@@ -1,6 +1,34 @@
 import logger from 'loglevel';
-import { DEFAULT_BUILD_CONFIG_FILE } from '../build_remote.js';
-import { resolveProjectRuntime, ensureProjectServiceRunning } from './project_runtime.js';
+import { addProjectTargetOptions, resolveProjectRuntime, ensureProjectServiceRunning } from './project_runtime.js';
+import { DEFAULT_PROJECT_SYNC_TARGET } from './project_sync.js';
+
+export async function ensureWorkdir(runtime, service, workdir) {
+	const normalized = String(workdir || '').trim();
+	if (!normalized) {
+		return '';
+	}
+	await runtime.bridge.lzcDockerComposeCapture([
+		'-p',
+		runtime.composeProjectName,
+		'exec',
+		'-T',
+		String(service || 'app'),
+		'mkdir',
+		'-p',
+		normalized,
+	]);
+	return normalized;
+}
+
+export function resolveProjectExecCommandArgs(cmd, passthrough) {
+	if (Array.isArray(cmd) && cmd.length > 0) {
+		return cmd.map((item) => String(item));
+	}
+	if (Array.isArray(passthrough) && passthrough.length > 0) {
+		return passthrough.map((item) => String(item));
+	}
+	return ['/bin/sh'];
+}
 
 export function projectExecCommand() {
 	return {
@@ -13,26 +41,35 @@ export function projectExecCommand() {
 				type: 'string',
 				default: 'app',
 			});
-			args.option('c', {
-				alias: 'config',
-				describe: 'Build config file name',
-				type: 'string',
-				default: DEFAULT_BUILD_CONFIG_FILE,
-			});
+			addProjectTargetOptions(args);
 			args.option('t', {
 				alias: 'tty',
 				describe: 'Allocate tty for exec',
 				type: 'boolean',
 				default: true,
 			});
+			args.option('w', {
+				alias: 'workdir',
+				describe: 'Working directory inside container',
+				type: 'string',
+				default: DEFAULT_PROJECT_SYNC_TARGET,
+			});
+			args.parserConfiguration({
+				'populate--': true,
+			});
 		},
-		handler: async ({ cmd, service, config, tty }) => {
-			const runtime = await resolveProjectRuntime(process.cwd(), config);
+		handler: async ({ cmd, '--': passthrough, service, config, dev, release, tty, workdir }) => {
+			const runtime = await resolveProjectRuntime(process.cwd(), { config, dev, release, command: 'lzc-cli project exec' });
+			logger.info(`Build config: ${runtime.configPath}`);
 			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 normalizedWorkdir = await ensureWorkdir(runtime, targetService, workdir);
+			const execCommand = resolveProjectExecCommandArgs(cmd, passthrough);
 
 			const composeArgs = ['-p', runtime.composeProjectName, 'exec'];
+			if (normalizedWorkdir) {
+				composeArgs.push('--workdir', normalizedWorkdir);
+			}
 			if (!tty) {
 				composeArgs.push('-T');
 			}

package/lib/app/project_info.js

@@ -1,6 +1,5 @@
 import logger from 'loglevel';
-import { DEFAULT_BUILD_CONFIG_FILE } from '../build_remote.js';
-import { resolveProjectRuntime, getProjectDeployInfo, getProjectComposePs, getProjectErrmsgByDeployId } from './project_runtime.js';
+import { addProjectTargetOptions, resolveProjectRuntime, getProjectDeployInfo, getProjectComposePs, getProjectErrmsgByDeployId } from './project_runtime.js';
 
 function takeFirstLines(text, maxLines = 50) {
 	const lines = String(text ?? '').split(/\r?\n/);
@@ -38,69 +37,70 @@ function resolveTargetUrl(domain) {
 	return `https://${rawDomain}`;
 }
 
+export async function printProjectInfo(runtime) {
+	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 deploy;
+	}
+	if (instanceStatusLower.includes('starting')) {
+		logger.info('Project app is starting. Please wait and run "lzc-cli project info" again.');
+		return deploy;
+	}
+	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 deploy;
+	}
+	logger.info('Project app is not running. Run "lzc-cli project start" first.');
+	return deploy;
+}
+
 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,
-			});
+			addProjectTargetOptions(args);
 		},
-		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.');
+		handler: async ({ config, dev, release }) => {
+			const runtime = await resolveProjectRuntime(process.cwd(), { config, dev, release, command: 'lzc-cli project info' });
+			logger.info(`Build config: ${runtime.configPath}`);
+			await printProjectInfo(runtime);
 		},
 	};
 }

package/lib/app/project_log.js

@@ -1,6 +1,5 @@
 import logger from 'loglevel';
-import { DEFAULT_BUILD_CONFIG_FILE } from '../build_remote.js';
-import { resolveProjectRuntime, ensureProjectRunning, ensureProjectServiceRunning, getComposeProject } from './project_runtime.js';
+import { addProjectTargetOptions, resolveProjectRuntime, ensureProjectRunning, ensureProjectServiceRunning, getComposeProject } from './project_runtime.js';
 
 export function projectLogCommand() {
 	return {
@@ -12,12 +11,7 @@ export function projectLogCommand() {
 				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,
-			});
+			addProjectTargetOptions(args);
 			args.option('f', {
 				alias: 'follow',
 				describe: 'Follow log output',
@@ -34,8 +28,9 @@ export function projectLogCommand() {
 				type: 'string',
 			});
 		},
-		handler: async ({ service, config, follow, tail, since }) => {
-			const runtime = await resolveProjectRuntime(process.cwd(), config);
+		handler: async ({ service, config, dev, release, follow, tail, since }) => {
+			const runtime = await resolveProjectRuntime(process.cwd(), { config, dev, release, command: 'lzc-cli project log' });
+			logger.info(`Build config: ${runtime.configPath}`);
 			const targetService = String(service ?? '').trim();
 			if (targetService) {
 				await ensureProjectServiceRunning(runtime, targetService);