@webmate-studio/cli 0.3.62 → 0.4.0

package/src/commands/clone.js

@@ -0,0 +1,414 @@
+import { existsSync, readdirSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { basename, dirname, join, 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 { writeMeta } from '../utils/webmate-meta.js';
+import {
+	writeComponentFiles,
+	computeFileHashesFromMap
+} from '../utils/component-files.js';
+import { autoSnapshot } from '../utils/git-snapshot.js';
+
+function slugify(value) {
+	return (value || '')
+		.toString()
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, '-')
+		.replace(/^-+|-+$/g, '');
+}
+
+const DEFAULT_WM_CONFIG = `export default {
+	components: {
+		path: './components',
+		styles: ['./tokens/tokens.css', './styles/base.css'],
+		fonts: [],
+		islands: {
+			path: './islands',
+			framework: 'lit'
+		}
+	},
+	preview: {
+		port: 5173,
+		theme: 'light',
+		viewport: { width: 1440, height: 900 }
+	}
+};
+`;
+
+function parseSource(spec) {
+	if (!spec) return null;
+	const at = spec.lastIndexOf('@');
+	if (at < 0) return { sourceComponentId: spec, sourceVersion: null };
+	return {
+		sourceComponentId: spec.slice(0, at),
+		sourceVersion: spec.slice(at + 1) || null
+	};
+}
+
+function resolveTargetDir(arg) {
+	const cwd = process.cwd();
+	return arg ? resolve(cwd, arg) : cwd;
+}
+
+async function resolveSourceVersionId({ sourceComponentId, sourceVersion }) {
+	if (!sourceVersion || sourceVersion === 'latest') return null;
+	if (/^cm[0-9a-z]{20,}$/i.test(sourceVersion)) return sourceVersion;
+	const list = await apiFetch(
+		`/api/organization/components/${sourceComponentId}/versions`
+	);
+	const versions = list?.versions ?? [];
+	const match = versions.find((v) => v.version === sourceVersion);
+	if (!match) {
+		throw new Error(
+			`Version "${sourceVersion}" not found among ${versions.length} versions of ${sourceComponentId}`
+		);
+	}
+	return match.id;
+}
+
+export async function cloneCommand(projectArgs, options = {}) {
+	// `wm clone foo bar baz` arrives as ['foo', 'bar', 'baz'] thanks to the
+	// variadic positional. Join with spaces so project names with whitespace
+	// work without forcing the user to quote them.
+	const projectArg = Array.isArray(projectArgs) ? projectArgs.join(' ').trim() : (projectArgs ?? '').trim();
+
+	// Two modes share the verb:
+	//   * `wm clone <project>` — project bootstrap (this file, below)
+	//   * `wm clone --from <uuid>` — single-component clone (legacy, server-side)
+	// We can't use both at once.
+	if (projectArg && options.from) {
+		logger.error('Cannot combine positional <project> with --from. Use one mode at a time.');
+		process.exit(1);
+	}
+	if (!projectArg && !options.from) {
+		logger.error('Either a project name/id or --from <component-uuid>[@<version>] is required.');
+		process.exit(1);
+	}
+
+	if (projectArg) {
+		return cloneProjectCommand(projectArg, options);
+	}
+
+	return cloneComponentCommand(options);
+}
+
+async function cloneComponentCommand(options = {}) {
+	const parsed = parseSource(options.from);
+	if (!parsed?.sourceComponentId) {
+		logger.error(`Invalid --from value: ${options.from}`);
+		process.exit(1);
+	}
+
+	const targetDir = resolveTargetDir(options.to);
+
+	if (existsSync(targetDir) && readdirSync(targetDir).length > 0 && !options.force) {
+		const proceed = await confirm({
+			message: `Target ${pc.cyan(targetDir)} is not empty. Continue and overwrite?`,
+			default: false
+		});
+		if (!proceed) {
+			logger.info('Clone cancelled.');
+			return;
+		}
+	}
+
+	let sourceVersionId;
+	try {
+		sourceVersionId = await resolveSourceVersionId({
+			sourceComponentId: parsed.sourceComponentId,
+			sourceVersion: parsed.sourceVersion
+		});
+	} catch (err) {
+		if (err instanceof ApiError) {
+			logger.error(`Could not list source versions (HTTP ${err.status}): ${err.message}`);
+		} else {
+			logger.error(err.message);
+		}
+		process.exit(1);
+	}
+
+	const spinner = ora('Cloning component on server…').start();
+	let result;
+	try {
+		const body = {
+			sourceComponentId: parsed.sourceComponentId
+		};
+		if (sourceVersionId) body.sourceVersionId = sourceVersionId;
+		if (options.targetOrg) body.targetOrganizationSlug = options.targetOrg;
+		if (options.targetOrgId) body.targetOrganizationId = options.targetOrgId;
+		if (options.name) body.targetName = options.name;
+		if (options.category) body.targetCategory = options.category;
+
+		result = await apiFetch('/api/organization/components/clone', {
+			method: 'POST',
+			body
+		});
+		spinner.succeed(
+			`Cloned to new component ${pc.cyan(result.newComponentId)} ` +
+			`${pc.dim('(org ' + result.newOrganizationId + ')')}`
+		);
+	} catch (err) {
+		if (err instanceof ApiError) {
+			spinner.fail(`Clone failed (HTTP ${err.status}): ${err.message}`);
+		} else {
+			spinner.fail(err.message);
+		}
+		process.exit(1);
+	}
+
+	const files = result?.files ?? {};
+	if (!Object.keys(files).length) {
+		logger.warn('Server returned no files. Aborting before touching disk.');
+		process.exit(1);
+	}
+
+	mkdirSync(targetDir, { recursive: true });
+	writeComponentFiles(targetDir, files, { clean: !options.merge });
+
+	const fileHashes = computeFileHashesFromMap(files);
+	const cloneAuth = resolveAuth();
+	const meta = writeMeta(targetDir, {
+		componentId: result.newComponentId,
+		baseVersion: null,
+		version: null,
+		pulledAt: new Date().toISOString(),
+		fileHashes,
+		originRepositoryId: cloneAuth?.repositoryId ?? null
+	});
+
+	logger.success(`Wrote ${Object.keys(files).length} file(s) to ${pc.dim(targetDir)}`);
+	console.log(`  New component ID: ${pc.cyan(result.newComponentId)}`);
+	console.log(`  Target org:       ${pc.dim(result.newOrganizationId)}`);
+	console.log(`  Source:           ${pc.dim(result.source.componentId + '@' + result.source.version)}`);
+	console.log(`  Manifest:         ${pc.dim(meta && targetDir + '/.webmate.json')}`);
+
+	const snap = await autoSnapshot(
+		targetDir,
+		`wm clone from ${result.source.componentId}@${result.source.version}`,
+		{ 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)')}`);
+	}
+
+	console.log();
+	console.log(pc.bold('Next step:') + ' run ' + pc.cyan(`wm push ${basename(targetDir)} --force`));
+	console.log(pc.dim('  (--force is needed for the very first push because there is no baseVersion yet)'));
+}
+
+// Walk up from `start` (inclusive) toward the filesystem root. Returns the
+// first ancestor that looks like an existing webmate workspace (has a
+// wm.config.js or a workspace-shaped .webmate/config.json), or null if
+// there is none. Used to stop `wm clone <project>` from creating a
+// sub-workspace inside an existing one — which is the classic footgun
+// that pollutes the parent's components/ tree with another full workspace.
+//
+// Workspace vs. global config: `~/.webmate/config.json` is also created by
+// the CLI for global state (just { cmsUrl: ... }) and must not be treated
+// as a workspace marker — otherwise running `wm clone` from $HOME refuses
+// with a misleading "you're inside a workspace" error. We disambiguate by
+// peeking at the file: only configs that carry a `repositoryId` (or, for
+// freshly initialised but not-yet-bound workspaces, a `componentsPath`)
+// are real workspaces.
+function isWorkspaceConfigFile(path) {
+	try {
+		const raw = readFileSync(path, 'utf-8');
+		const data = JSON.parse(raw);
+		if (!data || typeof data !== 'object') return false;
+		return Boolean(data.repositoryId || data.componentsPath);
+	} catch {
+		return false;
+	}
+}
+function findEnclosingWorkspace(start) {
+	let dir = start;
+	while (true) {
+		if (existsSync(join(dir, 'wm.config.js'))) return dir;
+		const cfg = join(dir, '.webmate', 'config.json');
+		if (existsSync(cfg) && isWorkspaceConfigFile(cfg)) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+
+async function cloneProjectCommand(projectArg, options = {}) {
+	// Refuse to nest workspaces. If the user invokes `wm clone <project>`
+	// from inside an existing workspace (or anywhere under its tree —
+	// most commonly inside its components/ folder), the resulting clone
+	// would land as a sub-workspace and every parent-walk component
+	// scanner would happily fold its contents into the outer workspace.
+	// We prefer a hard stop with a clear pointer to a safer location
+	// over the silent disaster.
+	const enclosing = findEnclosingWorkspace(process.cwd());
+	if (enclosing && !options.force) {
+		logger.error(
+			`Refusing to clone into a nested workspace.\n` +
+			`  Current directory is inside the workspace at ${pc.cyan(enclosing)}.\n` +
+			`  Run \`wm clone\` from a folder that is not itself a workspace — typically the parent:\n` +
+			`    ${pc.dim('cd ' + dirname(enclosing))}\n` +
+			`    ${pc.cyan('wm clone ' + projectArg)}\n` +
+			`  Or pass ${pc.bold('--force')} if you really mean to nest.`
+		);
+		process.exit(1);
+	}
+
+	// 1. Resolve the project (= ComponentRepository) — accept id or name.
+	const lookup = ora(`Looking up project ${pc.cyan(projectArg)}…`).start();
+	let repo;
+	try {
+		const res = await apiFetch('/api/organization/repositories');
+		const repos = Array.isArray(res?.repositories) ? res.repositories : [];
+		repo = repos.find(r => r.id === projectArg || r.name === projectArg);
+		if (!repo) {
+			lookup.fail(`Project "${projectArg}" not found in your organization.`);
+			console.log(pc.dim('  Available projects:'));
+			for (const r of repos) {
+				console.log(`    ${pc.cyan(r.name)} ${pc.dim('(' + r.id + ')')}`);
+			}
+			process.exit(1);
+		}
+		lookup.succeed(`Project ${pc.cyan(repo.name)} ${pc.dim('(' + repo.id + ')')}`);
+	} catch (err) {
+		if (err instanceof ApiError) {
+			lookup.fail(`Could not list projects (HTTP ${err.status}): ${err.message}`);
+		} else {
+			lookup.fail(err.message);
+		}
+		process.exit(1);
+	}
+
+	// 2. Decide target directory.
+	const dirName = options.to ? options.to : slugify(repo.name);
+	const targetDir = resolve(process.cwd(), dirName);
+
+	if (existsSync(targetDir) && readdirSync(targetDir).length > 0 && !options.force) {
+		const proceed = await confirm({
+			message: `Target ${pc.cyan(targetDir)} is not empty. Continue and overwrite?`,
+			default: false
+		});
+		if (!proceed) {
+			logger.info('Clone cancelled.');
+			return;
+		}
+	}
+
+	// 3. List components in this repo (filter client-side from the org list).
+	const compsSpinner = ora('Listing components…').start();
+	let components;
+	try {
+		const res = await apiFetch('/api/organization/components');
+		const all = Array.isArray(res?.components) ? res.components : [];
+		components = all.filter(c => c.repository?.id === repo.id || c.repositoryId === repo.id);
+		compsSpinner.succeed(
+			`Found ${pc.cyan(components.length)} component(s) in ${pc.cyan(repo.name)}`
+		);
+	} catch (err) {
+		if (err instanceof ApiError) {
+			compsSpinner.fail(`Could not list components (HTTP ${err.status}): ${err.message}`);
+		} else {
+			compsSpinner.fail(err.message);
+		}
+		process.exit(1);
+	}
+
+	// 4. Lay out the workspace skeleton.
+	mkdirSync(targetDir, { recursive: true });
+	mkdirSync(join(targetDir, 'components'), { recursive: true });
+
+	const configPath = join(targetDir, 'wm.config.js');
+	if (!existsSync(configPath)) {
+		writeFileSync(configPath, DEFAULT_WM_CONFIG, 'utf-8');
+	}
+
+	const auth = resolveAuth();
+	const dotWebmateDir = join(targetDir, '.webmate');
+	mkdirSync(dotWebmateDir, { recursive: true });
+	const workspaceConfig = {
+		organizationId: auth?.organizationId ?? null,
+		organizationSlug: auth?.organizationSlug ?? null,
+		organizationName: auth?.organizationName ?? null,
+		repositoryId: repo.id,
+		repositoryName: repo.name,
+		clonedAt: new Date().toISOString()
+	};
+	writeFileSync(
+		join(dotWebmateDir, 'config.json'),
+		JSON.stringify(workspaceConfig, null, 2) + '\n',
+		'utf-8'
+	);
+	logger.success(`Workspace scaffolded at ${pc.dim(targetDir)}`);
+
+	// 5. Pull source for every published component.
+	let pulled = 0;
+	let skipped = 0;
+	for (const comp of components) {
+		const versionId =
+			comp.latestVersion && typeof comp.latestVersion === 'object'
+				? comp.latestVersion.id
+				: null;
+		const versionLabel =
+			comp.latestVersion && typeof comp.latestVersion === 'object'
+				? comp.latestVersion.version
+				: typeof comp.latestVersion === 'string'
+					? comp.latestVersion
+					: null;
+		const compSlug = slugify(comp.name) || slugify(comp.displayName) || comp.id.slice(0, 8);
+		const compDir = join(targetDir, 'components', compSlug);
+
+		if (!versionId) {
+			logger.warn(`  · ${comp.name}: no published version — skipped`);
+			skipped++;
+			continue;
+		}
+
+		const pullSpinner = ora(`Pulling ${comp.name} ${pc.dim('v' + versionLabel)}…`).start();
+		try {
+			const source = await apiFetch(
+				`/api/organization/components/${comp.id}/versions/${versionId}/source`
+			);
+			const files = source?.files ?? {};
+			if (!Object.keys(files).length) {
+				pullSpinner.warn(`${comp.name}: empty source bundle — skipped`);
+				skipped++;
+				continue;
+			}
+			mkdirSync(compDir, { recursive: true });
+			writeComponentFiles(compDir, files, { clean: true });
+			const fileHashes = computeFileHashesFromMap(files);
+			writeMeta(compDir, {
+				componentId: comp.id,
+				baseVersion: versionId,
+				version: versionLabel,
+				pulledAt: new Date().toISOString(),
+				fileHashes,
+				originRepositoryId: repo.id
+			});
+			pullSpinner.succeed(`${comp.name} ${pc.dim('v' + versionLabel)}`);
+			pulled++;
+		} catch (err) {
+			if (err instanceof ApiError) {
+				pullSpinner.fail(`${comp.name}: HTTP ${err.status} — ${err.message}`);
+			} else {
+				pullSpinner.fail(`${comp.name}: ${err.message}`);
+			}
+			skipped++;
+		}
+	}
+
+	// 6. Recap + next steps.
+	console.log();
+	logger.success(
+		`Cloned project ${pc.cyan(repo.name)} — ${pulled} component(s) pulled, ${skipped} skipped`
+	);
+	console.log();
+	console.log(pc.bold('Next steps:'));
+	console.log(`  ${pc.cyan('cd ' + dirName)}`);
+	console.log(`  ${pc.cyan('wm dev')}`);
+}

package/src/commands/components.js

@@ -0,0 +1,101 @@
+import ora from 'ora';
+import pc from 'picocolors';
+import { logger } from '@webmate-studio/core';
+import { apiFetch, ApiError } from '../utils/api-client.js';
+import { tenantApiFetch, resolveTenantSubdomain } from '../utils/tenant-api.js';
+
+function buildQuery(opts) {
+	const params = new URLSearchParams();
+	if (opts.org) params.set('orgSlug', opts.org);
+	if (opts.orgId) params.set('orgId', opts.orgId);
+	if (opts.category) params.set('category', opts.category);
+	if (opts.search) params.set('search', opts.search);
+	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) + '…';
+}
+
+function latestVersionLabel(c) {
+	const lv = c.latestVersion;
+	if (lv && typeof lv === 'object') return lv.version ?? '—';
+	if (typeof lv === 'string') return lv;
+	return '—';
+}
+
+export async function componentsListCommand(options = {}) {
+	const query = buildQuery(options);
+	const spinner = ora('Fetching components…').start();
+	let response;
+	try {
+		// Tenant-Modus: --org wird ignoriert (Components leben nun pro Website),
+		// dafür liest der Endpoint die Website aus dem Auth-Tenant-Kontext.
+		// Legacy: org-weite Liste mit ?orgSlug=… wie bisher.
+		const sub = resolveTenantSubdomain(null);
+		if (sub) {
+			response = await tenantApiFetch(`/api/tenant-components`, {}, { tenantSubdomain: sub });
+		} else {
+			response = await apiFetch(`/api/organization/components${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 components =
+		response?.components ??
+		response?.data ??
+		(Array.isArray(response) ? response : []);
+
+	if (!Array.isArray(components) || components.length === 0) {
+		logger.info(
+			options.org
+				? `No components in organization "${options.org}".`
+				: 'No components in current organization.'
+		);
+		return;
+	}
+
+	const orgLabel = options.org ?? pc.dim('(current org)');
+	console.log();
+	console.log(pc.bold(`${components.length} component(s) in ${orgLabel}`));
+	console.log();
+
+	const ID_W = 36;
+	const NAME_W = 30;
+	const CAT_W = 18;
+	const VER_W = 12;
+
+	console.log(
+		pc.dim(
+			`${'UUID'.padEnd(ID_W)}  ${'Name'.padEnd(NAME_W)}  ${'Category'.padEnd(CAT_W)}  ${'Latest'.padEnd(VER_W)}`
+		)
+	);
+	console.log(
+		pc.dim('-'.repeat(ID_W) + '  ' + '-'.repeat(NAME_W) + '  ' + '-'.repeat(CAT_W) + '  ' + '-'.repeat(VER_W))
+	);
+
+	for (const c of components) {
+		const id = c.id ?? '';
+		const name = truncate(c.displayName ?? c.name ?? '', NAME_W);
+		const cat = truncate(c.category ?? '', CAT_W);
+		const ver = truncate(latestVersionLabel(c), VER_W);
+		const dep = c.deprecated ? pc.yellow(' (deprecated)') : '';
+		console.log(
+			`${pc.dim(String(id).padEnd(ID_W))}  ${name.padEnd(NAME_W)}  ${pc.dim(cat.padEnd(CAT_W))}  ${pc.cyan(ver.padEnd(VER_W))}${dep}`
+		);
+	}
+
+	console.log();
+	console.log(pc.dim(`  wm clone --from <uuid>[@<ver>] --to <dir>`));
+}