@webmate-studio/cli 0.3.62 → 0.4.0

package/src/commands/projects.js

@@ -0,0 +1,91 @@
+import ora from 'ora';
+import pc from 'picocolors';
+import { logger } from '@webmate-studio/core';
+import { apiFetch, ApiError } from '../utils/api-client.js';
+
+function buildQuery(opts) {
+	const params = new URLSearchParams();
+	if (opts.org) params.set('orgSlug', opts.org);
+	if (opts.orgId) params.set('orgId', opts.orgId);
+	const qs = params.toString();
+	return qs ? `?${qs}` : '';
+}
+
+function truncate(value, n) {
+	const s = typeof value === 'string' ? value : value == null ? '' : String(value);
+	if (!s) return '';
+	if (s.length <= n) return s;
+	return s.slice(0, n - 1) + '…';
+}
+
+export async function projectsListCommand(options = {}) {
+	const query = buildQuery(options);
+	const spinner = ora('Fetching projects…').start();
+	let response;
+	try {
+		response = await apiFetch(`/api/organization/repositories${query}`);
+		spinner.stop();
+	} catch (err) {
+		if (err instanceof ApiError) {
+			spinner.fail(`Fetch failed (HTTP ${err.status}): ${err.message}`);
+		} else {
+			spinner.fail(err.message);
+		}
+		process.exit(1);
+	}
+
+	const repositories = Array.isArray(response?.repositories) ? response.repositories : [];
+
+	if (repositories.length === 0) {
+		logger.info(
+			options.org
+				? `No projects in organization "${options.org}".`
+				: 'No projects in current organization.'
+		);
+		return;
+	}
+
+	const orgLabel = options.org ?? pc.dim('(current org)');
+	console.log();
+	console.log(pc.bold(`${repositories.length} project(s) in ${orgLabel}`));
+	console.log();
+
+	const NAME_W = 30;
+	const ID_W = 36;
+	const TYPE_W = 6;
+	const BRANCH_W = 16;
+	const COUNT_W = 5;
+
+	console.log(
+		pc.dim(
+			`${'Name'.padEnd(NAME_W)}  ${'ID'.padEnd(ID_W)}  ${'Type'.padEnd(TYPE_W)}  ${'Branch'.padEnd(BRANCH_W)}  ${'#Cmp'.padStart(COUNT_W)}`
+		)
+	);
+	console.log(
+		pc.dim(
+			'-'.repeat(NAME_W) +
+				'  ' +
+				'-'.repeat(ID_W) +
+				'  ' +
+				'-'.repeat(TYPE_W) +
+				'  ' +
+				'-'.repeat(BRANCH_W) +
+				'  ' +
+				'-'.repeat(COUNT_W)
+		)
+	);
+
+	for (const r of repositories) {
+		const name = truncate(r.name ?? '', NAME_W).padEnd(NAME_W);
+		const id = String(r.id ?? '').padEnd(ID_W);
+		const typeStr = (r.isInternal ? 'intern' : 'github').padEnd(TYPE_W);
+		const typeColored = r.isInternal ? pc.magenta(typeStr) : pc.cyan(typeStr);
+		const branchStr = r.isInternal ? '—' : r.branch ?? '—';
+		const branch = truncate(branchStr, BRANCH_W).padEnd(BRANCH_W);
+		const count = String(r.componentCount ?? 0).padStart(COUNT_W);
+		console.log(`${name}  ${pc.dim(id)}  ${typeColored}  ${pc.dim(branch)}  ${pc.cyan(count)}`);
+	}
+
+	console.log();
+	console.log(pc.dim('  wm clone <name>   bootstrap a workspace for a project'));
+}

package/src/commands/pull.js

@@ -0,0 +1,192 @@
+import { existsSync, mkdirSync, readdirSync } from 'fs';
+import { join, resolve, basename } from 'path';
+import { confirm } from '@inquirer/prompts';
+import ora from 'ora';
+import pc from 'picocolors';
+import { logger } from '@webmate-studio/core';
+import { apiFetch, ApiError } from '../utils/api-client.js';
+import { resolveAuth } from '../utils/auth-resolver.js';
+import { readMeta, writeMeta, getMetaPath } from '../utils/webmate-meta.js';
+import { tenantApiFetch, resolveTenantSubdomain } from '../utils/tenant-api.js';
+import {
+	readComponentFiles,
+	writeComponentFiles,
+	computeFileHashesFromMap,
+	diffHashes,
+	getComponentId
+} from '../utils/component-files.js';
+import { autoSnapshot } from '../utils/git-snapshot.js';
+
+function resolveComponentDir(arg) {
+	const cwd = process.cwd();
+	if (!arg) return cwd;
+	return resolve(cwd, arg);
+}
+
+async function pickComponentId({ rootDir, meta, optionId }) {
+	if (optionId) return optionId;
+	if (meta?.componentId) return meta.componentId;
+	if (existsSync(join(rootDir, 'component.json'))) {
+		try {
+			return getComponentId(rootDir).id;
+		} catch {
+			// fall through
+		}
+	}
+	const err = new Error(
+		'No component id found. Pass --id <uuid>, or run from a directory containing component.json or .webmate.json.'
+	);
+	err.code = 'WM_NO_COMPONENT_ID';
+	throw err;
+}
+
+async function fetchVersionsList(componentId, meta) {
+	const sub = resolveTenantSubdomain(meta);
+	const path = sub
+		? `/api/tenant-components/${componentId}/versions`
+		: `/api/organization/components/${componentId}/versions`;
+	return tenantApiFetch(path, {}, meta);
+}
+
+async function fetchSource(componentId, versionId, meta) {
+	const sub = resolveTenantSubdomain(meta);
+	const path = sub
+		? `/api/tenant-components/${componentId}/versions/${versionId}/source`
+		: `/api/organization/components/${componentId}/versions/${versionId}/source`;
+	return tenantApiFetch(path, {}, meta);
+}
+
+async function resolveVersionId({ componentId, requested, meta }) {
+	const list = await fetchVersionsList(componentId, meta);
+	const versions = list?.versions ?? [];
+	if (!versions.length) {
+		throw new Error(`No versions exist yet for component ${componentId}`);
+	}
+	if (!requested || requested === 'latest') {
+		return versions[0];
+	}
+	const match = versions.find((v) => v.id === requested || v.version === requested);
+	if (!match) {
+		throw new Error(`Version "${requested}" not found among ${versions.length} versions`);
+	}
+	return match;
+}
+
+function summariseChanges(diff) {
+	const parts = [];
+	if (diff.added.length) parts.push(`${diff.added.length} added`);
+	if (diff.modified.length) parts.push(`${diff.modified.length} modified`);
+	if (diff.removed.length) parts.push(`${diff.removed.length} removed`);
+	return parts.length ? parts.join(', ') : 'no changes';
+}
+
+export async function pullCommand(componentArg, options = {}) {
+	const rootDir = resolveComponentDir(componentArg);
+
+	if (!existsSync(rootDir)) {
+		mkdirSync(rootDir, { recursive: true });
+		logger.info(`Created directory ${pc.dim(rootDir)}`);
+	}
+
+	const meta = readMeta(rootDir);
+
+	let componentId;
+	try {
+		componentId = await pickComponentId({ rootDir, meta, optionId: options.id });
+	} catch (err) {
+		logger.error(err.message);
+		process.exit(1);
+	}
+
+	// Detect local changes before overwriting
+	const dirHasContent = readdirSync(rootDir).some((n) => n !== '.webmate.json');
+	if (dirHasContent && meta?.fileHashes) {
+		const { fileHashes: localHashes } = readComponentFiles(rootDir);
+		const localDiff = diffHashes(localHashes, meta.fileHashes);
+		const hasLocal =
+			localDiff.added.length || localDiff.modified.length || localDiff.removed.length;
+		if (hasLocal && !options.force) {
+			console.log(
+				pc.yellow(`Local changes detected since last pull: ${summariseChanges(localDiff)}`)
+			);
+			for (const p of [...localDiff.modified, ...localDiff.added].slice(0, 10)) {
+				console.log(`  ${pc.yellow('M')} ${p}`);
+			}
+			for (const p of localDiff.removed.slice(0, 10)) {
+				console.log(`  ${pc.red('D')} ${p}`);
+			}
+			const proceed = await confirm({
+				message: 'Overwrite local changes?',
+				default: false
+			});
+			if (!proceed) {
+				logger.info('Pull cancelled.');
+				return;
+			}
+		}
+	}
+
+	let version;
+	try {
+		version = await resolveVersionId({ componentId, requested: options.version, meta });
+	} catch (err) {
+		if (err instanceof ApiError) {
+			logger.error(`Could not list versions (HTTP ${err.status}): ${err.message}`);
+		} else {
+			logger.error(err.message);
+		}
+		process.exit(1);
+	}
+
+	const spinner = ora(`Pulling ${pc.cyan(version.version)} (${pc.dim(version.id.slice(0, 8))})…`).start();
+	let source;
+	try {
+		source = await fetchSource(componentId, version.id, meta);
+		spinner.succeed(`Fetched source for ${pc.cyan(version.version)}.`);
+	} catch (err) {
+		if (err instanceof ApiError) {
+			spinner.fail(`Pull failed (HTTP ${err.status}): ${err.message}`);
+		} else {
+			spinner.fail(err.message);
+		}
+		process.exit(1);
+	}
+
+	const remoteFiles = source?.files ?? {};
+	if (!remoteFiles || !Object.keys(remoteFiles).length) {
+		logger.warn('Remote returned no files. Nothing to write.');
+		return;
+	}
+
+	writeComponentFiles(rootDir, remoteFiles, { clean: !options.merge });
+
+	const fileHashes = computeFileHashesFromMap(remoteFiles);
+	const pullAuth = resolveAuth();
+	const writePayload = {
+		componentId,
+		baseVersion: version.id,
+		version: version.version,
+		pulledAt: new Date().toISOString(),
+		fileHashes,
+		originRepositoryId: pullAuth?.repositoryId ?? null
+	};
+	const sub = resolveTenantSubdomain(meta);
+	if (sub) writePayload.tenantSubdomain = sub;
+	const written = writeMeta(rootDir, writePayload);
+
+	logger.success(`Pulled into ${pc.dim(rootDir)}`);
+	console.log(`  Version:      ${pc.cyan(written.version)} ${pc.dim('(' + written.baseVersion + ')')}`);
+	console.log(`  Files:        ${pc.dim(Object.keys(remoteFiles).length + ' file(s)')}`);
+	console.log(`  Manifest:     ${pc.dim(getMetaPath(rootDir))}`);
+
+	const snap = await autoSnapshot(
+		rootDir,
+		`wm pull ${written.version} (${written.baseVersion})`,
+		{ skip: options.noGit }
+	);
+	if (snap.committed) {
+		console.log(`  Git snapshot: ${pc.dim(snap.sha)}`);
+	} else if (snap.skipped && snap.reason === 'no-git') {
+		console.log(`  Git snapshot: ${pc.dim('skipped (no .git)')}`);
+	}
+}

package/src/commands/push.js

@@ -0,0 +1,231 @@
+import { existsSync } from 'fs';
+import { basename, resolve } from 'path';
+import { confirm } from '@inquirer/prompts';
+import ora from 'ora';
+import pc from 'picocolors';
+import { logger } from '@webmate-studio/core';
+import { apiFetch, ApiError } from '../utils/api-client.js';
+import { resolveAuth } from '../utils/auth-resolver.js';
+import { readMeta, writeMeta } from '../utils/webmate-meta.js';
+import { tenantApiFetch, resolveTenantSubdomain } from '../utils/tenant-api.js';
+import {
+	readComponentFiles,
+	diffHashes,
+	getComponentId
+} from '../utils/component-files.js';
+import { autoSnapshot } from '../utils/git-snapshot.js';
+
+function resolveComponentDir(arg) {
+	const cwd = process.cwd();
+	if (!arg) return cwd;
+	return resolve(cwd, arg);
+}
+
+async function fetchLatestRemote(componentId, meta) {
+	const sub = resolveTenantSubdomain(meta);
+	const path = sub
+		? `/api/tenant-components/${componentId}/versions`
+		: `/api/organization/components/${componentId}/versions`;
+	const list = await tenantApiFetch(path, {}, meta);
+	const versions = list?.versions ?? [];
+	return versions[0] ?? null;
+}
+
+function summariseLocalDiff(diff) {
+	const parts = [];
+	if (diff.added.length) parts.push(`${diff.added.length} added`);
+	if (diff.modified.length) parts.push(`${diff.modified.length} modified`);
+	if (diff.removed.length) parts.push(`${diff.removed.length} removed`);
+	return parts.length ? parts.join(', ') : null;
+}
+
+export async function pushCommand(componentArg, options = {}) {
+	const rootDir = resolveComponentDir(componentArg);
+
+	if (!existsSync(rootDir)) {
+		logger.error(`Directory not found: ${rootDir}`);
+		process.exit(1);
+	}
+
+	let componentInfo;
+	try {
+		componentInfo = getComponentId(rootDir);
+	} catch (err) {
+		logger.error(err.message);
+		process.exit(1);
+	}
+
+	const componentId = componentInfo.id;
+	const meta = readMeta(rootDir);
+
+	if (!meta && !options.force) {
+		const proceed = await confirm({
+			message: `No .webmate.json found. Push ${pc.cyan(componentInfo.displayName ?? componentId)} without a baseVersion (skips conflict check)?`,
+			default: false
+		});
+		if (!proceed) {
+			logger.info('Push cancelled.');
+			return;
+		}
+	}
+
+	const { files, fileHashes } = readComponentFiles(rootDir);
+
+	// Only short-circuit on identical hashes when there IS a baseVersion to
+	// compare against. Locally-generated or freshly-cloned components have
+	// baseVersion=null and must always go through the upload path — their
+	// fileHashes match the on-disk files (we just wrote them) but the server
+	// has never seen them yet.
+	if (meta?.fileHashes && meta?.baseVersion) {
+		const localDiff = diffHashes(fileHashes, meta.fileHashes);
+		const summary = summariseLocalDiff(localDiff);
+		if (!summary) {
+			if (options.force) {
+				console.log(pc.dim('No local changes since last pull/push — pushing anyway (--force).'));
+			} else {
+				logger.info('No local changes since last pull/push. Nothing to upload.');
+				return;
+			}
+		} else {
+			console.log(`Local changes: ${pc.cyan(summary)}`);
+		}
+	} else if (!meta?.baseVersion) {
+		console.log(pc.dim('First push — uploading new component to the server.'));
+	}
+
+	const preflight = ora('Checking remote head…').start();
+	let remoteLatest;
+	try {
+		remoteLatest = await fetchLatestRemote(componentId, meta);
+		preflight.succeed(
+			remoteLatest
+				? `Remote head: ${pc.cyan(remoteLatest.version)} ${pc.dim('(' + remoteLatest.id.slice(0, 8) + ')')}`
+				: 'Remote has no versions yet — first push.'
+		);
+	} catch (err) {
+		// A first-push (baseVersion=null) is expected to 404 — the component
+		// doesn't exist on the server yet. The POST below will create it.
+		if (err instanceof ApiError && err.status === 404 && !meta?.baseVersion) {
+			preflight.succeed('No remote yet — first push will create the component.');
+			remoteLatest = null;
+		} else if (err instanceof ApiError) {
+			preflight.fail(`Could not reach remote (HTTP ${err.status}): ${err.message}`);
+			process.exit(1);
+		} else {
+			preflight.fail(err.message);
+			process.exit(1);
+		}
+	}
+
+	if (meta?.baseVersion && remoteLatest && remoteLatest.id !== meta.baseVersion) {
+		console.log();
+		logger.error(
+			`Remote moved: your baseVersion is ${meta.baseVersion} ` +
+			`but remote latest is ${remoteLatest.id} (${remoteLatest.version}).`
+		);
+		console.log(`  Run ${pc.bold('wm pull')} first, then push again.`);
+		if (!options.force) process.exit(1);
+		console.log(pc.yellow('  --force given: pushing anyway (server will refuse on baseVersion mismatch).'));
+	}
+
+	const body = { files };
+	if (meta?.baseVersion) body.baseVersion = meta.baseVersion;
+	if (options.message) body.commitMessage = options.message;
+
+	// First-push hints — these are ignored by the server when the component
+	// already exists. They let the server create the component on the fly
+	// when this is the first push for a locally-generated/cloned component.
+	if (!meta?.baseVersion) {
+		body.name = basename(rootDir);
+		const auth = resolveAuth();
+		// targetRepositoryId nur im Legacy-Modus — der tenant-Endpoint
+		// braucht es nicht (Component lebt direkt im Tenant).
+		if (!resolveTenantSubdomain(meta) && auth?.repositoryId) {
+			body.targetRepositoryId = auth.repositoryId;
+		}
+		if (meta?.clonedFrom) {
+			body.clonedFrom = meta.clonedFrom;
+		}
+	}
+
+	const spinner = ora('Uploading and building…').start();
+	let result;
+	try {
+		const sub = resolveTenantSubdomain(meta);
+		const pushPath = sub
+			? `/api/tenant-components/${componentId}/versions`
+			: `/api/organization/components/${componentId}/versions`;
+		result = await tenantApiFetch(pushPath, { method: 'POST', body }, meta);
+		spinner.succeed(`Built and published ${pc.cyan(result.version)} ${pc.dim('(' + result.versionId.slice(0, 8) + ')')}`);
+	} catch (err) {
+		if (err instanceof ApiError) {
+			if (err.status === 409) {
+				spinner.fail(
+					`Conflict: remote moved to ${err.body?.currentVersion ?? '?'} ` +
+					`(${err.body?.currentVersionId ?? '?'}). Run \`wm pull\` first.`
+				);
+			} else if (err.status === 422) {
+				spinner.fail(`Build failed (HTTP 422): ${err.body?.message ?? err.message}`);
+			} else {
+				spinner.fail(`Push failed (HTTP ${err.status}): ${err.message}`);
+			}
+		} else {
+			spinner.fail(err.message);
+		}
+		process.exit(1);
+	}
+
+	// Stamp the workspace's bound repository into meta so the scanner can
+	// later distinguish "really deleted upstream" from "this meta was
+	// authored against a different project and copied here" — see
+	// preview-server bulk-status state classifier.
+	const pushAuth = resolveAuth();
+	const writePayload = {
+		componentId,
+		baseVersion: result.versionId,
+		version: result.version,
+		pulledAt: new Date().toISOString(),
+		fileHashes,
+		originRepositoryId: pushAuth?.repositoryId ?? null
+	};
+	// Tenant-Subdomain persistieren — der nächste push/pull weiß damit
+	// ohne env-Variable, dass die Component im neuen Routing lebt.
+	const sub = resolveTenantSubdomain(meta);
+	if (sub) writePayload.tenantSubdomain = sub;
+
+	const written = writeMeta(rootDir, writePayload);
+
+	logger.success(`Pushed ${pc.cyan(componentInfo.displayName ?? componentId)} as ${pc.cyan(written.version)}`);
+	if (result.previousVersion) {
+		console.log(`  Previous:  ${pc.dim(result.previousVersion)}`);
+	}
+	console.log(`  Files:     ${pc.dim(Object.keys(files).length + ' file(s)')}`);
+
+	// Impact awareness: any tenant the project is linked to via
+	// TenantRepositoryLink('auto') now serves this version. Surfacing
+	// this is the explicit mitigation against "I pushed something half-
+	// finished and it went live somewhere I didn't expect".
+	if (Array.isArray(result.impactedWebsites) && result.impactedWebsites.length > 0) {
+		const labels = result.impactedWebsites
+			.map((w) => w.name || w.subdomain || w.id)
+			.filter(Boolean);
+		console.log(
+			`  ${pc.yellow('Live on:')}  ${labels.join(', ')} ${pc.dim('(' + labels.length + ')')}`
+		);
+	}
+
+	const snap = await autoSnapshot(
+		rootDir,
+		options.message
+			? `wm push ${written.version}: ${options.message}`
+			: `wm push ${written.version} (${written.baseVersion})`,
+		{ skip: options.noGit }
+	);
+	if (snap.committed) {
+		console.log(`  Git:       ${pc.dim('committed ' + snap.sha)}`);
+	} else if (snap.skipped && snap.reason === 'no-git') {
+		console.log(`  Git:       ${pc.dim('skipped (no .git)')}`);
+	} else if (snap.skipped && snap.reason === 'no-changes') {
+		console.log(`  Git:       ${pc.dim('nothing to snapshot')}`);
+	}
+}

package/src/commands/reset.js

@@ -0,0 +1,118 @@
+/**
+ * `wm reset [dir]` — drop the sync pointer in `.webmate.json` so the next
+ * `wm push` re-registers the component as a fresh one.
+ *
+ * Why this exists: when a developer copies an existing component folder
+ * (incl. its `.webmate.json`) into a new workspace bound to a different
+ * project, the `baseVersion` it carries refers to a version-CUID that
+ * only exists in the original project's CMS. The status scanner sees
+ * "baseVersion set + CMS doesn't know this id" and flags the component
+ * as `deleted-upstream` ("once lived here, now gone"), which is
+ * misleading — the component never lived in the new project at all.
+ *
+ * Reset clears `baseVersion` and `fileHashes` but keeps `componentId`,
+ * so the component is back in the `never-pushed` state and `wm push`
+ * will create it on the target server.
+ *
+ * Workspace mode: if `dir` contains a `components/` subfolder (the
+ * convention used by `wm clone <project>` and `wm core clone`), reset
+ * every component under it. Otherwise treat `dir` as a single component
+ * folder.
+ */
+
+import { existsSync, statSync, readdirSync } from 'fs';
+import { resolve, join, basename } from 'path';
+import pc from 'picocolors';
+import { logger } from '@webmate-studio/core';
+import { readMeta, writeMeta } from '../utils/webmate-meta.js';
+import { getComponentId } from '../utils/component-files.js';
+
+function isComponentDir(dir) {
+	return existsSync(join(dir, 'component.json'));
+}
+
+function listComponentDirs(rootDir) {
+	const componentsRoot = join(rootDir, 'components');
+	if (existsSync(componentsRoot) && statSync(componentsRoot).isDirectory()) {
+		// Workspace layout
+		return readdirSync(componentsRoot)
+			.map((name) => join(componentsRoot, name))
+			.filter((p) => statSync(p).isDirectory() && isComponentDir(p));
+	}
+	if (isComponentDir(rootDir)) return [rootDir];
+	return [];
+}
+
+function resetOne(componentDir) {
+	const meta = readMeta(componentDir);
+	const slug = basename(componentDir);
+
+	if (!meta) {
+		// No .webmate.json — adopt the component from its component.json so
+		// the preview/sidebar treats it as never-pushed (visible "Neu" badge)
+		// instead of unlinked (no badge, no action). Same end state as a
+		// reset of a stale meta, just bootstrapped from scratch.
+		let info;
+		try {
+			info = getComponentId(componentDir);
+		} catch (err) {
+			return { slug, skipped: true, reason: err.message };
+		}
+		writeMeta(componentDir, {
+			componentId: info.id,
+			baseVersion: null,
+			fileHashes: {}
+		});
+		return { slug, reset: true, adopted: true };
+	}
+
+	if (meta.baseVersion == null && (!meta.fileHashes || Object.keys(meta.fileHashes).length === 0)) {
+		return { slug, skipped: true, reason: 'already reset' };
+	}
+	writeMeta(componentDir, {
+		componentId: meta.componentId,
+		baseVersion: null,
+		fileHashes: {}
+	});
+	return { slug, reset: true, hadBaseVersion: !!meta.baseVersion };
+}
+
+export async function resetCommand(dirArg) {
+	const rootDir = resolve(process.cwd(), dirArg ?? '.');
+	if (!existsSync(rootDir)) {
+		logger.error(`Directory not found: ${rootDir}`);
+		process.exit(1);
+	}
+
+	const dirs = listComponentDirs(rootDir);
+	if (dirs.length === 0) {
+		logger.error(
+			`No components found in ${rootDir}. Pass a component folder or a workspace root with a components/ subfolder.`
+		);
+		process.exit(1);
+	}
+
+	let reset = 0;
+	let adopted = 0;
+	let skipped = 0;
+	for (const dir of dirs) {
+		const result = resetOne(dir);
+		if (result.adopted) {
+			adopted++;
+			console.log(`  ${pc.cyan('●')}  ${result.slug.padEnd(40)} ${pc.dim('adopted (new .webmate.json)')}`);
+		} else if (result.reset) {
+			reset++;
+			console.log(`  ${pc.green('●')}  ${result.slug.padEnd(40)} ${pc.dim('reset')}`);
+		} else {
+			skipped++;
+			console.log(`  ${pc.dim('○')}  ${result.slug.padEnd(40)} ${pc.dim('skipped — ' + result.reason)}`);
+		}
+	}
+
+	console.log();
+	console.log(`  ${pc.bold(reset)} reset · ${pc.bold(adopted)} adopted · ${pc.bold(skipped)} skipped`);
+	if (reset + adopted > 0) {
+		console.log();
+		console.log(`  Run ${pc.bold('wm push')} to register the component(s) on the server.`);
+	}
+}