@lazycatcloud/lzc-cli 1.3.17 → 2.0.0-pre.1

package/lib/app/project_exec.js

@@ -0,0 +1,82 @@
+import logger from 'loglevel';
+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 {
+		command: 'exec [cmd..]',
+		desc: 'Execute command in a project service container',
+		builder: (args) => {
+			args.option('s', {
+				alias: 'service',
+				describe: 'Service name in docker compose project',
+				type: 'string',
+				default: 'app',
+			});
+			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, '--': 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 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');
+			}
+			composeArgs.push(targetService, ...execCommand);
+
+			logger.debug('project exec:', composeArgs.join(' '));
+			await runtime.bridge.lzcDockerCompose(composeArgs);
+		},
+	};
+}

package/lib/app/project_info.js

@@ -0,0 +1,106 @@
+import logger from 'loglevel';
+import { addProjectTargetOptions, resolveProjectRuntime, getProjectDeployInfo, getProjectComposePs, getProjectErrmsgByDeployId } from './project_runtime.js';
+
+function takeFirstLines(text, maxLines = 50) {
+	const lines = String(text ?? '').split(/\r?\n/);
+	const limit = Number.isInteger(maxLines) && maxLines > 0 ? maxLines : 50;
+	if (lines.length <= limit) {
+		return {
+			text: lines.join('\n'),
+			truncated: false,
+		};
+	}
+	return {
+		text: lines.slice(0, limit).join('\n'),
+		truncated: true,
+	};
+}
+
+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();
+}
+
+function resolveTargetUrl(domain) {
+	const rawDomain = String(domain ?? '').trim();
+	if (!rawDomain) {
+		return '';
+	}
+	if (rawDomain.startsWith('http://') || rawDomain.startsWith('https://')) {
+		return rawDomain;
+	}
+	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) => {
+			addProjectTargetOptions(args);
+		},
+		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

@@ -0,0 +1,62 @@
+import logger from 'loglevel';
+import { addProjectTargetOptions, resolveProjectRuntime, ensureProjectRunning, ensureProjectServiceRunning, getComposeProject } from './project_runtime.js';
+
+export function projectLogCommand() {
+	return {
+		command: 'log',
+		desc: 'Show logs of project containers',
+		builder: (args) => {
+			args.option('s', {
+				alias: 'service',
+				describe: 'Service name in docker compose project',
+				type: 'string',
+			});
+			addProjectTargetOptions(args);
+			args.option('f', {
+				alias: 'follow',
+				describe: 'Follow log output',
+				type: 'boolean',
+				default: true,
+			});
+			args.option('tail', {
+				describe: 'Number of lines to show from the end of logs',
+				type: 'number',
+				default: 200,
+			});
+			args.option('since', {
+				describe: 'Show logs since timestamp or relative duration',
+				type: 'string',
+			});
+		},
+		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);
+			} else {
+				await ensureProjectRunning(runtime);
+				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 composeArgs = ['-p', runtime.composeProjectName, 'logs'];
+			if (follow) {
+				composeArgs.push('-f');
+			}
+			if (tail !== undefined && tail !== null) {
+				composeArgs.push('--tail', String(tail));
+			}
+			if (since) {
+				composeArgs.push('--since', String(since));
+			}
+			if (targetService) {
+				composeArgs.push(targetService);
+			}
+
+			logger.debug('project log:', composeArgs.join(' '));
+			await runtime.bridge.lzcDockerCompose(composeArgs);
+		},
+	};
+}

package/lib/app/project_runtime.js

@@ -0,0 +1,356 @@
+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 = DEFAULT_BUILD_CONFIG_FILE;
+
+function isFile(pathname) {
+	return fs.existsSync(pathname) && fs.statSync(pathname).isFile();
+}
+
+function normalizeProjectTargetSelection(selection = '') {
+	if (typeof selection === 'string') {
+		return {
+			config: String(selection ?? '').trim(),
+			dev: false,
+			release: false,
+		};
+	}
+	if (!selection || typeof selection !== 'object') {
+		return {
+			config: '',
+			dev: false,
+			release: false,
+		};
+	}
+	return {
+		config: String(selection.config ?? '').trim(),
+		dev: !!selection.dev,
+		release: !!selection.release,
+	};
+}
+
+export function addProjectTargetOptions(args) {
+	args.option('c', {
+		alias: 'config',
+		describe: 'Build config file name',
+		type: 'string',
+	});
+	args.option('dev', {
+		describe: `Use ${DEFAULT_DEPLOY_BUILD_CONFIG_FILE}`,
+		type: 'boolean',
+		default: false,
+	});
+	args.option('release', {
+		describe: `Use ${DEFAULT_RELEASE_BUILD_CONFIG_FILE}`,
+		type: 'boolean',
+		default: false,
+	});
+}
+
+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 '';
+}
+
+function resolveExplicitBuildConfigPath(startDir, selection) {
+	const normalized = normalizeProjectTargetSelection(selection);
+	if (normalized.dev && normalized.release) {
+		throw new Error('Cannot use --dev and --release together.');
+	}
+	if (normalized.config && (normalized.dev || normalized.release)) {
+		throw new Error('Cannot combine --config with --dev or --release.');
+	}
+	if (normalized.config) {
+		const explicitPath = resolveBuildConfigPath(startDir, normalized.config);
+		if (!explicitPath) {
+			throw new Error(`Build config file not found: ${normalized.config}`);
+		}
+		return explicitPath;
+	}
+	if (normalized.dev) {
+		const devPath = resolveBuildConfigPath(startDir, DEFAULT_DEPLOY_BUILD_CONFIG_FILE);
+		if (!devPath) {
+			throw new Error(`Build config file not found: ${DEFAULT_DEPLOY_BUILD_CONFIG_FILE}`);
+		}
+		return devPath;
+	}
+	if (normalized.release) {
+		const releasePath = resolveBuildConfigPath(startDir, DEFAULT_RELEASE_BUILD_CONFIG_FILE);
+		if (!releasePath) {
+			throw new Error(`Build config file not found: ${DEFAULT_RELEASE_BUILD_CONFIG_FILE}`);
+		}
+		return releasePath;
+	}
+	return '';
+}
+
+export function resolveProjectDeployConfigPath(startDir = process.cwd(), selection = '') {
+	const explicitPath = resolveExplicitBuildConfigPath(startDir, selection);
+	if (explicitPath) {
+		return explicitPath;
+	}
+
+	const preferredConfigPath = resolveBuildConfigPath(startDir, DEFAULT_DEPLOY_BUILD_CONFIG_FILE);
+	if (preferredConfigPath) {
+		return preferredConfigPath;
+	}
+
+	const defaultConfigPath = resolveBuildConfigPath(startDir, DEFAULT_RELEASE_BUILD_CONFIG_FILE);
+	if (!defaultConfigPath) {
+		throw new Error(`Build config file not found: ${DEFAULT_DEPLOY_BUILD_CONFIG_FILE} or ${DEFAULT_RELEASE_BUILD_CONFIG_FILE}`);
+	}
+	return defaultConfigPath;
+}
+
+export function resolveProjectReleaseConfigPath(startDir = process.cwd(), selection = '') {
+	const normalized = normalizeProjectTargetSelection(selection);
+	if (normalized.dev) {
+		throw new Error('Release command does not support --dev. Use --release or omit the flag.');
+	}
+	const explicitConfig = normalized.config;
+	if (explicitConfig) {
+		const explicitPath = resolveBuildConfigPath(startDir, explicitConfig);
+		if (!explicitPath) {
+			throw new Error(`Build config file not found: ${explicitConfig}`);
+		}
+		return explicitPath;
+	}
+
+	const defaultConfigPath = resolveBuildConfigPath(startDir, DEFAULT_RELEASE_BUILD_CONFIG_FILE);
+	if (!defaultConfigPath) {
+		throw new Error(`Build config file not found: ${DEFAULT_RELEASE_BUILD_CONFIG_FILE}`);
+	}
+	return defaultConfigPath;
+}
+
+export function resolveProjectCommandConfigPath(startDir = process.cwd(), selection = '') {
+	const explicitPath = resolveExplicitBuildConfigPath(startDir, selection);
+	if (explicitPath) {
+		return explicitPath;
+	}
+
+	const devPath = resolveBuildConfigPath(startDir, DEFAULT_DEPLOY_BUILD_CONFIG_FILE);
+	if (devPath) {
+		return devPath;
+	}
+	const releasePath = resolveBuildConfigPath(startDir, DEFAULT_RELEASE_BUILD_CONFIG_FILE);
+	if (releasePath) {
+		return releasePath;
+	}
+	throw new Error(`Build config file not found: ${DEFAULT_DEPLOY_BUILD_CONFIG_FILE} or ${DEFAULT_RELEASE_BUILD_CONFIG_FILE}`);
+}
+
+export async function resolveProjectRuntime(startDir = process.cwd(), selection = '') {
+	const configPath = resolveProjectCommandConfigPath(startDir, selection);
+
+	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,95 @@
+import logger from 'loglevel';
+import { LpkBuild } from './lpk_build.js';
+import { addProjectTargetOptions, 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, { forceV2: true }).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) => {
+			addProjectTargetOptions(args);
+			args.option('restart', {
+				describe: 'Force restart app instance',
+				type: 'boolean',
+				default: false,
+			});
+		},
+		handler: async ({ config, dev, release, restart }) => {
+			const runtime = await resolveProjectRuntime(process.cwd(), { config, dev, release, command: 'lzc-cli project start' });
+			logger.info(`Build config: ${runtime.configPath}`);
+			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);
+			}
+		},
+	};
+}