@multiplatform.one/cli 5.0.27 → 6.0.1

package/lib/bin/multiplatformOne.mjs

@@ -1,573 +1,837 @@
-// src/bin/multiplatformOne.ts
-import fsSync from "node:fs";
+import { generateVscodeConfig } from "../generateVscode.mjs";
+import { discoverE2EApp, runE2ESession } from "../commands/e2e.mjs";
+import { init, runModifyStep } from "../commands/init.mjs";
+import { createRequire } from "node:module";
 import fs from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
+import fsSync from "node:fs";
 import { fileURLToPath } from "node:url";
-import {
-  formatServiceList,
-  lookupProjectRoot,
-  waitForApi,
-  waitForFrappe,
-  waitForKeycloak,
-  waitForPostgres,
-  waitServices
-} from "@multiplatform.one/utils/dev";
-import { program } from "commander";
-import dotenv from "dotenv";
-import { execa } from "execa";
-import inquirer from "inquirer";
-import ora from "ora";
-var projectRoot = lookupProjectRoot();
-var availableServices = ["api", "frappe", "solana", "ethereum", "sui"];
-var defaultDotenvPath = path.resolve(projectRoot, ".env");
-var availablePlatforms = [
-  "electron",
-  "expo",
-  "keycloak",
-  "one",
-  "storybook",
-  "storybook-expo",
-  "vocs",
-  "vscode",
-  "webext"
+import { formatServiceList, lookupProjectRoot, waitForFrappe, waitForKeycloak, waitForPostgres, waitServices } from "@multiplatform.one/utils/dev";
+import { Command } from "commander";
+import spawn from "nano-spawn";
+import YAML from "yaml";
+import yoctoSpinner from "yocto-spinner";
+
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region ../../node_modules/dotenv/lib/main.js
+var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs$1 = __require("fs");
+	const path$1 = __require("path");
+	const os = __require("os");
+	const crypto = __require("crypto");
+	const TIPS = [
+		"◈ encrypted .env [www.dotenvx.com]",
+		"◈ secrets for agents [www.dotenvx.com]",
+		"⌁ auth for agents [www.vestauth.com]",
+		"⌘ custom filepath { path: '/custom/path/.env' }",
+		"⌘ enable debugging { debug: true }",
+		"⌘ override existing { override: true }",
+		"⌘ suppress logs { quiet: true }",
+		"⌘ multiple files { path: ['.env.local', '.env'] }"
+	];
+	function _getRandomTip() {
+		return TIPS[Math.floor(Math.random() * TIPS.length)];
+	}
+	function parseBoolean(value) {
+		if (typeof value === "string") return ![
+			"false",
+			"0",
+			"no",
+			"off",
+			""
+		].includes(value.toLowerCase());
+		return Boolean(value);
+	}
+	function supportsAnsi() {
+		return process.stdout.isTTY;
+	}
+	function dim(text) {
+		return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text;
+	}
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+	function parse(src) {
+		const obj = {};
+		let lines = src.toString();
+		lines = lines.replace(/\r\n?/gm, "\n");
+		let match;
+		while ((match = LINE.exec(lines)) != null) {
+			const key = match[1];
+			let value = match[2] || "";
+			value = value.trim();
+			const maybeQuote = value[0];
+			value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2");
+			if (maybeQuote === "\"") {
+				value = value.replace(/\\n/g, "\n");
+				value = value.replace(/\\r/g, "\r");
+			}
+			obj[key] = value;
+		}
+		return obj;
+	}
+	function _parseVault(options) {
+		options = options || {};
+		const vaultPath = _vaultPath(options);
+		options.path = vaultPath;
+		const result = DotenvModule.configDotenv(options);
+		if (!result.parsed) {
+			const err = /* @__PURE__ */ new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+			err.code = "MISSING_DATA";
+			throw err;
+		}
+		const keys = _dotenvKey(options).split(",");
+		const length = keys.length;
+		let decrypted;
+		for (let i = 0; i < length; i++) try {
+			const attrs = _instructions(result, keys[i].trim());
+			decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+			break;
+		} catch (error) {
+			if (i + 1 >= length) throw error;
+		}
+		return DotenvModule.parse(decrypted);
+	}
+	function _warn(message) {
+		console.error(`⚠ ${message}`);
+	}
+	function _debug(message) {
+		console.log(`┆ ${message}`);
+	}
+	function _log(message) {
+		console.log(`◇ ${message}`);
+	}
+	function _dotenvKey(options) {
+		if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) return options.DOTENV_KEY;
+		if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) return process.env.DOTENV_KEY;
+		return "";
+	}
+	function _instructions(result, dotenvKey) {
+		let uri;
+		try {
+			uri = new URL(dotenvKey);
+		} catch (error) {
+			if (error.code === "ERR_INVALID_URL") {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			}
+			throw error;
+		}
+		const key = uri.password;
+		if (!key) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing key part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environment = uri.searchParams.get("environment");
+		if (!environment) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing environment part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+		const ciphertext = result.parsed[environmentKey];
+		if (!ciphertext) {
+			const err = /* @__PURE__ */ new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+			err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+			throw err;
+		}
+		return {
+			ciphertext,
+			key
+		};
+	}
+	function _vaultPath(options) {
+		let possibleVaultPath = null;
+		if (options && options.path && options.path.length > 0) if (Array.isArray(options.path)) {
+			for (const filepath of options.path) if (fs$1.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+		} else possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+		else possibleVaultPath = path$1.resolve(process.cwd(), ".env.vault");
+		if (fs$1.existsSync(possibleVaultPath)) return possibleVaultPath;
+		return null;
+	}
+	function _resolveHome(envPath) {
+		return envPath[0] === "~" ? path$1.join(os.homedir(), envPath.slice(1)) : envPath;
+	}
+	function _configVault(options) {
+		const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+		const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (debug || !quiet) _log("loading env from encrypted .env.vault");
+		const parsed = DotenvModule._parseVault(options);
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		DotenvModule.populate(processEnv, parsed, options);
+		return { parsed };
+	}
+	function configDotenv(options) {
+		const dotenvPath = path$1.resolve(process.cwd(), ".env");
+		let encoding = "utf8";
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+		let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (options && options.encoding) encoding = options.encoding;
+		else if (debug) _debug("no encoding is specified (UTF-8 is used by default)");
+		let optionPaths = [dotenvPath];
+		if (options && options.path) if (!Array.isArray(options.path)) optionPaths = [_resolveHome(options.path)];
+		else {
+			optionPaths = [];
+			for (const filepath of options.path) optionPaths.push(_resolveHome(filepath));
+		}
+		let lastError;
+		const parsedAll = {};
+		for (const path of optionPaths) try {
+			const parsed = DotenvModule.parse(fs$1.readFileSync(path, { encoding }));
+			DotenvModule.populate(parsedAll, parsed, options);
+		} catch (e) {
+			if (debug) _debug(`failed to load ${path} ${e.message}`);
+			lastError = e;
+		}
+		const populated = DotenvModule.populate(processEnv, parsedAll, options);
+		debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+		quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+		if (debug || !quiet) {
+			const keysCount = Object.keys(populated).length;
+			const shortPaths = [];
+			for (const filePath of optionPaths) try {
+				const relative = path$1.relative(process.cwd(), filePath);
+				shortPaths.push(relative);
+			} catch (e) {
+				if (debug) _debug(`failed to load ${filePath} ${e.message}`);
+				lastError = e;
+			}
+			_log(`injected env (${keysCount}) from ${shortPaths.join(",")} ${dim(`// tip: ${_getRandomTip()}`)}`);
+		}
+		if (lastError) return {
+			parsed: parsedAll,
+			error: lastError
+		};
+		else return { parsed: parsedAll };
+	}
+	function config(options) {
+		if (_dotenvKey(options).length === 0) return DotenvModule.configDotenv(options);
+		const vaultPath = _vaultPath(options);
+		if (!vaultPath) {
+			_warn(`you set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}`);
+			return DotenvModule.configDotenv(options);
+		}
+		return DotenvModule._configVault(options);
+	}
+	function decrypt(encrypted, keyStr) {
+		const key = Buffer.from(keyStr.slice(-64), "hex");
+		let ciphertext = Buffer.from(encrypted, "base64");
+		const nonce = ciphertext.subarray(0, 12);
+		const authTag = ciphertext.subarray(-16);
+		ciphertext = ciphertext.subarray(12, -16);
+		try {
+			const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+			aesgcm.setAuthTag(authTag);
+			return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+		} catch (error) {
+			const isRange = error instanceof RangeError;
+			const invalidKeyLength = error.message === "Invalid key length";
+			const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+			if (isRange || invalidKeyLength) {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			} else if (decryptionFailed) {
+				const err = /* @__PURE__ */ new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+				err.code = "DECRYPTION_FAILED";
+				throw err;
+			} else throw error;
+		}
+	}
+	function populate(processEnv, parsed, options = {}) {
+		const debug = Boolean(options && options.debug);
+		const override = Boolean(options && options.override);
+		const populated = {};
+		if (typeof parsed !== "object") {
+			const err = /* @__PURE__ */ new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+			err.code = "OBJECT_REQUIRED";
+			throw err;
+		}
+		for (const key of Object.keys(parsed)) if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+			if (override === true) {
+				processEnv[key] = parsed[key];
+				populated[key] = parsed[key];
+			}
+			if (debug) if (override === true) _debug(`"${key}" is already defined and WAS overwritten`);
+			else _debug(`"${key}" is already defined and was NOT overwritten`);
+		} else {
+			processEnv[key] = parsed[key];
+			populated[key] = parsed[key];
+		}
+		return populated;
+	}
+	const DotenvModule = {
+		configDotenv,
+		_configVault,
+		_parseVault,
+		config,
+		decrypt,
+		parse,
+		populate
+	};
+	module.exports.configDotenv = DotenvModule.configDotenv;
+	module.exports._configVault = DotenvModule._configVault;
+	module.exports._parseVault = DotenvModule._parseVault;
+	module.exports.config = DotenvModule.config;
+	module.exports.decrypt = DotenvModule.decrypt;
+	module.exports.parse = DotenvModule.parse;
+	module.exports.populate = DotenvModule.populate;
+	module.exports = DotenvModule;
+}));
+
+//#endregion
+//#region src/bin/multiplatformOne.ts
+var import_main = /* @__PURE__ */ __toESM(require_main(), 1);
+const projectRoot = lookupProjectRoot();
+const availableServices = [
+	"api",
+	"frappe",
+	"solana",
+	"ethereum",
+	"sui"
 ];
-process.env.COOKIECUTTER = `sh ${path.resolve(
-  path.dirname(fileURLToPath(import.meta.url)),
-  "../../scripts/cookiecutter.sh"
-)}`;
-program.name("multiplatform.one");
-program.version(
-  JSON.parse(
-    fsSync.readFileSync(
-      path.resolve(
-        path.dirname(fileURLToPath(import.meta.url)),
-        "../../package.json"
-      ),
-      "utf8"
-    )
-  )?.version
-);
-program.command("init").option(
-  "-r, --remote <remote>",
-  "the remote to use",
-  "https://gitlab.com/bitspur/multiplatform.one/cookiecutter"
-).option(
-  "-c, --checkout <branch>",
-  "branch, tag or commit to checkout",
-  "main"
-).option("-p, --platforms <platforms>", "platforms to use").option("-s, --services <services>", "services to use").argument("[name]", "the name of the project", "").description("init multiplatform.one").action(async (name, options) => {
-  let { services, platforms } = options;
-  if ((await execa("git", ["rev-parse", "--is-inside-work-tree"], {
-    reject: false
-  })).exitCode === 0) {
-    throw new Error(
-      "multiplatform.one cannot be initialized inside a git repository"
-    );
-  }
-  if (!name) {
-    name = (await inquirer.prompt([
-      {
-        message: "What is the project name?",
-        name: "name",
-        type: "input"
-      }
-    ])).name;
-  }
-  if (!services) {
-    const servicesResult = (await inquirer.prompt([
-      {
-        message: "What services are you using?",
-        name: "services",
-        type: "checkbox",
-        choices: availableServices.map((name2) => ({ name: name2 }))
-      }
-    ])).services;
-    services = servicesResult.join(",");
-  }
-  if (!platforms) {
-    const platformsResult = (await inquirer.prompt([
-      {
-        message: "What platforms are you using?",
-        name: "platforms",
-        type: "checkbox",
-        choices: availablePlatforms.map((name2) => ({ name: name2 }))
-      }
-    ])).platforms;
-    platforms = platformsResult.join(",");
-  }
-  const cookieCutterConfig = {
-    default_context: { name, platforms, services }
-  };
-  const cookieCutterConfigFile = path.join(
-    await fs.mkdtemp(path.join(os.tmpdir(), "multiplatform-")),
-    "config.json"
-  );
-  try {
-    await fs.writeFile(
-      cookieCutterConfigFile,
-      JSON.stringify(cookieCutterConfig, null, 2)
-    );
-    await execa(
-      "sh",
-      [
-        path.resolve(
-          path.dirname(fileURLToPath(import.meta.url)),
-          "../../scripts/init.sh"
-        ),
-        "--no-input",
-        "-f",
-        "--config-file",
-        cookieCutterConfigFile,
-        "--checkout",
-        options.checkout,
-        options.remote
-      ],
-      {
-        stdio: "inherit"
-      }
-    );
-  } finally {
-    await fs.rm(cookieCutterConfigFile, { recursive: true, force: true });
-  }
+/** Map a service name to its relative directory from the project root. */
+function serviceDir(name) {
+	return `apps/${name}`;
+}
+const defaultDotenvPath = path.resolve(projectRoot, ".env");
+/** Apps that exist under apps/ and have package.json (discovered from filesystem). */
+async function getPresentApps(root) {
+	const appsDir = path.join(root, "apps");
+	try {
+		const entries = await fs.readdir(appsDir, { withFileTypes: true });
+		const names = [];
+		for (const e of entries) {
+			if (!e.isDirectory()) continue;
+			const pkgPath = path.join(appsDir, e.name, "package.json");
+			try {
+				await fs.access(pkgPath);
+				names.push(e.name);
+			} catch {}
+		}
+		return names;
+	} catch {
+		return [];
+	}
+}
+/** Root-level services that exist and have package.json (discovered from filesystem). */
+async function getPresentServices(root) {
+	const names = [];
+	for (const name of availableServices) {
+		const dir = path.join(root, serviceDir(name));
+		const pkgPath = path.join(dir, "package.json");
+		try {
+			if (!(await fs.stat(dir)).isDirectory()) continue;
+			await fs.access(pkgPath);
+			names.push(name);
+		} catch {}
+	}
+	return names;
+}
+/** Turbo --filter args to exclude root-level workspaces that are not present (so turbo only runs where they exist).
+*  Only generates exclude filters for directories that exist on disk (turbo errors on non-existent filter paths). */
+async function getTurboExcludeFiltersForMissing(root) {
+	const present = await getPresentServices(root);
+	const filters = [];
+	for (const s of availableServices) {
+		if (present.includes(s)) continue;
+		const dir = serviceDir(s);
+		try {
+			if ((await fs.stat(path.join(root, dir))).isDirectory()) filters.push(`!./${dir}`);
+		} catch {}
+	}
+	return filters;
+}
+async function getStorybookVisualWorkspaces(root) {
+	const out = [];
+	const searchDirs = [{
+		base: path.join(root, "apps"),
+		prefix: "apps/"
+	}, {
+		base: path.join(root, "packages"),
+		prefix: "packages/"
+	}];
+	for (const { base, prefix: _prefix } of searchDirs) {
+		let entries;
+		try {
+			entries = (await fs.readdir(base, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => ({ name: e.name }));
+		} catch {
+			continue;
+		}
+		for (const { name } of entries) {
+			const dirPath = path.join(base, name);
+			const storybookDir = path.join(dirPath, ".storybook");
+			try {
+				if (!(await fs.stat(storybookDir)).isDirectory()) continue;
+			} catch {
+				continue;
+			}
+			const pkgPath = path.join(dirPath, "package.json");
+			let pkg = null;
+			try {
+				pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
+			} catch {}
+			const hasLostPixel = pkg && (pkg.dependencies?.["lost-pixel"] || pkg.devDependencies?.["lost-pixel"]);
+			const scripts = pkg?.scripts ?? {};
+			const testVisualScript = scripts["test:visual"] ?? scripts["test/visual"] ?? scripts["test:visual:ci"];
+			const makefilePath = path.join(dirPath, "Makefile");
+			let makefileHasTestVisual = false;
+			try {
+				const makefile = await fs.readFile(makefilePath, "utf8");
+				makefileHasTestVisual = /test\/visual[\s:]/.test(makefile);
+			} catch {}
+			if (makefileHasTestVisual) out.push({
+				dirName: name,
+				absolutePath: dirPath,
+				runVisual: "make"
+			});
+			else if (testVisualScript) {
+				const scriptName = scripts["test:visual"] ? "test:visual" : scripts["test/visual"] ? "test/visual" : "test:visual:ci";
+				out.push({
+					dirName: name,
+					absolutePath: dirPath,
+					runVisual: "pnpm",
+					pnpmScript: scriptName
+				});
+			} else if (hasLostPixel) out.push({
+				dirName: name,
+				absolutePath: dirPath,
+				runVisual: "pnpm",
+				pnpmScript: void 0,
+				runLostPixelAfterBuild: true
+			});
+		}
+	}
+	return out;
+}
+/** Discover frappe apps from frappe.yaml that have local source paths.
+*  Supports both string entries (`- ./apps/core`) and object entries (`- name: core\n  source: ./apps/core`). */
+async function getFrappeApps(root) {
+	const frappeDir = path.join(root, "apps", "frappe");
+	const frappeYamlPath = path.join(frappeDir, "frappe.yaml");
+	if (!fsSync.existsSync(frappeYamlPath)) return [];
+	const raw = await fs.readFile(frappeYamlPath, "utf8");
+	const config = YAML.parse(raw);
+	const out = [];
+	for (const app of config?.apps ?? []) {
+		let src;
+		let name;
+		if (typeof app === "string") {
+			src = app;
+			name = path.basename(app);
+		} else {
+			if (!app.source || !app.name) continue;
+			src = app.source;
+			name = app.name;
+		}
+		src = src.startsWith("file://") ? src.slice(7) : src;
+		if (!src.startsWith("./") && !src.startsWith("../") && !src.startsWith("/")) continue;
+		const absPath = path.isAbsolute(src) ? src : path.resolve(frappeDir, src);
+		if (!fsSync.existsSync(absPath)) continue;
+		out.push({
+			name,
+			absolutePath: absPath
+		});
+	}
+	return out;
+}
+const program = new Command();
+program.name("mpo");
+program.version(JSON.parse(fsSync.readFileSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../package.json"), "utf8"))?.version);
+program.command("init").option("-c, --checkout <branch>", "branch, tag or commit to checkout", "main").option("-a, --apps <apps>", "comma-separated apps to include").option("-s, --services <services>", "comma-separated services to include").argument("[name]", "the name of the project").description("clone multiplatform.one and apply selected apps/services").action(async (name, options) => {
+	if (await spawn("git", ["rev-parse", "--is-inside-work-tree"]).then(() => true, () => false)) throw new Error("mpo cannot be initialized inside a git repository");
+	const cloneScript = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scripts/clone.sh");
+	await init(name, {
+		...options,
+		cloneScript
+	});
+});
+program.command("update").option("-c, --checkout <branch>", "branch, tag or commit to merge from upstream", "main").option("-r, --remote <url>", "upstream remote URL", "https://gitlab.com/bitspur/multiplatform.one/multiplatform.one.git").description("merge upstream and re-apply workspace config").action(async (options) => {
+	if (await spawn("git", ["rev-parse", "--is-inside-work-tree"]).then(() => false, () => true)) throw new Error("mpo cannot be updated outside of a git repository");
+	if (await spawn("git", [
+		"diff",
+		"--cached",
+		"--quiet"
+	]).then(() => false, () => true)) throw new Error("mpo cannot be updated with uncommitted changes (staged changes present)");
+	if (await spawn("git", ["diff", "--quiet"]).then(() => false, () => true)) throw new Error("multiplatform.one cannot be updated with uncommitted changes (unstaged changes present)");
+	const rootPkgPath = path.resolve(projectRoot, "package.json");
+	const featuresPkgPath = path.resolve(projectRoot, "features/package.json");
+	try {
+		if (!(await fs.stat(rootPkgPath)).isFile()) throw new Error("mpo update requires a valid project: root package.json not found");
+	} catch (err) {
+		if (err instanceof Error && err.message.includes("valid project")) throw err;
+		throw new Error("mpo update requires a valid project: root package.json not found");
+	}
+	try {
+		if (!(await fs.stat(featuresPkgPath)).isFile()) throw new Error("mpo update requires a valid project: features/package.json not found");
+	} catch (err) {
+		if (err instanceof Error && err.message.includes("valid project")) throw err;
+		throw new Error("mpo update requires a valid project: features/package.json not found");
+	}
+	const featuresPkg = JSON.parse(await fs.readFile(featuresPkgPath, "utf8"));
+	if (!featuresPkg?.dependencies?.["multiplatform.one"] || !String(featuresPkg.dependencies["multiplatform.one"]).length) throw new Error("mpo update requires a valid project: features must depend on multiplatform.one");
+	await spawn("sh", [
+		path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scripts/update.sh"),
+		options.remote,
+		options.checkout
+	], {
+		cwd: projectRoot,
+		stdio: "inherit",
+		shell: true
+	});
+	runModifyStep(projectRoot, await getPresentServices(projectRoot), await getPresentApps(projectRoot));
+	try {
+		await generateVscodeConfig(projectRoot);
+	} catch {}
+});
+program.command("wait").description("wait for a service to be ready").option("-i, --interval <interval>", "interval to wait for", "1000").option("-t, --timeout <timeout>", "timeout to wait for", "600000").option("-e, --dotenv <dotenv>", "dotenv file path", ".env").argument("<services>", `the services to wait for (${waitServices.join(", ")})`).action(async (servicesString, options) => {
+	import_main.default.config({ path: options.dotenv || defaultDotenvPath });
+	const interval = Number.parseInt(options.interval);
+	const timeout = Number.parseInt(options.timeout);
+	const services = servicesString.split(",");
+	try {
+		await waitWithSpinner(services, {
+			interval,
+			timeout
+		});
+	} catch {
+		process.exit(1);
+	}
+});
+const frappe = program.command("frappe").description("manage frappe development environment").option("-e, --dotenv <dotenv>", "dotenv file path", ".env");
+frappe.command("bootstrap").description("bootstrap frappe development environment").option("-u, --update", "update dependencies").action(async (options) => {
+	const parentOptions = frappe.opts();
+	import_main.default.config({ path: parentOptions.dotenv || defaultDotenvPath });
+	await spawn("sh", [
+		path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scripts/frappe.sh"),
+		"bootstrap",
+		...options.update ? ["--update"] : []
+	], {
+		stdio: "inherit",
+		shell: true,
+		cwd: projectRoot
+	});
 });
-program.command("update").option(
-  "-r, --remote <remote>",
-  "the remote to use",
-  "https://gitlab.com/bitspur/multiplatform.one/cookiecutter"
-).option(
-  "-c, --checkout <branch>",
-  "branch, tag or commit to checkout",
-  "main"
-).option("-p, --platforms <platforms>", "platforms to keep").option("-s, --services <services>", "services to keep").option("--no-prompt", "do not prompt for services and platforms").description("update multiplatform.one").action(
-  async (options) => {
-    let platforms = [];
-    let services = [];
-    if (!options.platforms) {
-      platforms = (await fs.readdir(path.join(projectRoot, "platforms"), {
-        withFileTypes: true
-      })).filter((d) => d.isDirectory()).map((d) => d.name).filter((name) => availablePlatforms.includes(name));
-    }
-    if (!options.services) {
-      services = (await fs.readdir(projectRoot, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name).filter((name) => availableServices.includes(name));
-    }
-    if (!options.noPrompt) {
-      const servicesResult = await inquirer.prompt([
-        {
-          message: "What services are you using?",
-          name: "services",
-          type: "checkbox",
-          choices: availableServices.map((name) => ({
-            name,
-            checked: services.includes(name)
-          }))
-        }
-      ]);
-      services = servicesResult.services;
-      const platformsResult = await inquirer.prompt([
-        {
-          message: "What platforms are you using?",
-          name: "platforms",
-          type: "checkbox",
-          choices: availablePlatforms.map((name) => ({
-            name,
-            checked: platforms.includes(name)
-          }))
-        }
-      ]);
-      platforms = platformsResult.platforms;
-    }
-    if ((await execa("git", ["rev-parse", "--is-inside-work-tree"], {
-      reject: false
-    })).exitCode !== 0) {
-      throw new Error(
-        "multiplatform.one cannot be updated outside of a git repository"
-      );
-    }
-    if ((await execa("git", ["diff", "--cached", "--quiet"], {
-      reject: false
-    })).exitCode !== 0) {
-      throw new Error(
-        "multiplatform.one cannot be updated with uncommitted changes"
-      );
-    }
-    let cookieCutterConfig;
-    if ((await fs.stat(path.resolve(projectRoot, "package.json"))).isFile() && (await fs.stat(path.resolve(projectRoot, "app/package.json"))).isFile() && JSON.parse(
-      await fs.readFile(
-        path.resolve(projectRoot, "app/package.json"),
-        "utf8"
-      )
-    )?.dependencies?.["multiplatform.one"]?.length) {
-      const name = JSON.parse(
-        await fs.readFile(path.resolve(projectRoot, "package.json"), "utf8")
-      )?.name;
-      if (name) {
-        cookieCutterConfig = {
-          default_context: {
-            name,
-            platforms: platforms.join(","),
-            services: services.join(",")
-          }
-        };
-      }
-    }
-    if (!cookieCutterConfig) {
-      throw new Error("not a multiplatform.one project");
-    }
-    const cookieCutterConfigFile = path.join(
-      await fs.mkdtemp(path.join(os.tmpdir(), "multiplatform-")),
-      "config.json"
-    );
-    try {
-      await fs.writeFile(
-        cookieCutterConfigFile,
-        JSON.stringify(cookieCutterConfig, null, 2)
-      );
-      await execa(
-        "sh",
-        [
-          path.resolve(
-            path.dirname(fileURLToPath(import.meta.url)),
-            "../../scripts/update.sh"
-          ),
-          "--no-input",
-          "-f",
-          "--config-file",
-          cookieCutterConfigFile,
-          "--checkout",
-          options.checkout,
-          options.remote
-        ],
-        {
-          cwd: projectRoot,
-          stdio: "inherit",
-          shell: true
-        }
-      );
-    } finally {
-      await fs.rm(cookieCutterConfigFile, { recursive: true, force: true });
-    }
-  }
-);
-program.command("wait").description("wait for a service to be ready").option("-i, --interval <interval>", "interval to wait for", "1000").option("-t, --timeout <timeout>", "timeout to wait for", "600000").option("-e, --dotenv <dotenv>", "dotenv file path", ".env").argument(
-  "<services>",
-  `the services to wait for (${waitServices.join(", ")})`
-).action(async (servicesString, options) => {
-  dotenv.config({ path: options.dotenv || defaultDotenvPath });
-  const interval = Number.parseInt(options.interval);
-  const timeout = Number.parseInt(options.timeout);
-  const services = servicesString.split(",");
-  try {
-    await waitWithSpinner(services, { interval, timeout });
-  } catch (err) {
-    process.exit(1);
-  }
+frappe.command("clean").description("clean frappe bench artifacts").option("--cache", "also remove frappe cache").action(async (options) => {
+	await spawn("sh", [
+		path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scripts/frappe.sh"),
+		"clean",
+		...options.cache ? ["--cache"] : []
+	], {
+		stdio: "inherit",
+		shell: true,
+		cwd: projectRoot
+	});
 });
-program.command("mesh").description("start the mesh server").option("-a, --api", "use api", false).option("-e, --dotenv <dotenv>", "dotenv file path", ".env").option("-f, --frappe", "use frappe", false).option("-i, --interval <interval>", "interval to wait for", "1000").option("-p, --port <port>", "port to run mesh on", "5002").option("-t, --timeout <timeout>", "timeout to wait for", "600000").action(async (options) => {
-  dotenv.config({ path: options.dotenv || defaultDotenvPath });
-  process.env.UWS_HTTP_MAX_HEADERS_SIZE = "16384";
-  if (options.frappe || options.api) {
-    process.env.MESH_API = options.api ? "1" : "0";
-    process.env.MESH_FRAPPE = options.frappe ? "1" : "0";
-  }
-  if (!await fs.stat(path.resolve(projectRoot, "app/main.ts")).catch(() => false)) {
-    process.env.MESH_APP = "0";
-  }
-  if (!await fs.stat(path.resolve(projectRoot, "frappe/package.json")).catch(() => false)) {
-    process.env.MESH_FRAPPE = "0";
-  }
-  const services = [
-    ...process.env.MESH_API === "1" ? ["api"] : [],
-    ...process.env.MESH_FRAPPE === "1" ? ["frappe"] : []
-  ];
-  if (services.length > 0) {
-    const interval = Number.parseInt(options.interval);
-    const timeout = Number.parseInt(options.timeout);
-    try {
-      await waitWithSpinner(services, { interval, timeout });
-    } catch (err) {
-      process.exit(1);
-    }
-  }
-  await execa(
-    "mesh",
-    [
-      "dev",
-      "--port",
-      Number(options.port || process.env.MESH_PORT || 5002).toString()
-    ],
-    {
-      stdio: "inherit"
-    }
-  );
+frappe.command("dev").description("start frappe development server").action(async () => {
+	const parentOptions = frappe.opts();
+	import_main.default.config({ path: parentOptions.dotenv || defaultDotenvPath });
+	await spawn("sh", [path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scripts/frappe.sh"), "dev"], {
+		stdio: "inherit",
+		shell: true,
+		cwd: projectRoot
+	});
 });
-program.command("build").argument(
-  "[args...]",
-  `build to run: ${[...availableServices, "packages"].join(", ")} (default: all)`
-).description("run build command").action(async (args) => {
-  args = args.flatMap((arg) => arg.split(","));
-  const packages = args.includes("packages");
-  const projects = args.filter((arg) => arg !== "packages");
-  if (!projects.length && !packages || packages) {
-    await execa(
-      "pnpm",
-      [
-        "turbo",
-        "run",
-        "build",
-        "--filter",
-        "'!./platforms/*'",
-        "--filter",
-        "'!./api'",
-        "--filter",
-        "'!./solana'",
-        "--filter",
-        "'!./ethereum'",
-        "--filter",
-        "'!./sui'"
-      ],
-      {
-        stdio: "inherit",
-        shell: true,
-        cwd: projectRoot
-      }
-    );
-  }
-  for (const platform of await fs.readdir("platforms")) {
-    if ((!projects.length && !packages || projects.includes(platform)) && await fs.access(path.join(projectRoot, "platforms", platform, "package.json")).then(
-      () => JSON.parse(
-        fsSync.readFileSync(
-          path.join(projectRoot, "platforms", platform, "package.json"),
-          "utf8"
-        )
-      ).scripts?.build
-    ).catch(() => false)) {
-      await execa("./mkpm", [`${platform}/build`], {
-        stdio: "inherit",
-        shell: true,
-        cwd: projectRoot
-      });
-    }
-  }
-  for (const service of availableServices) {
-    if ((!projects.length && !packages || projects.includes(service)) && await fs.access(path.join(projectRoot, service, "package.json")).then(
-      () => JSON.parse(
-        fsSync.readFileSync(
-          path.join(projectRoot, service, "package.json"),
-          "utf8"
-        )
-      ).scripts?.build
-    ).catch(() => false)) {
-      await execa("./mkpm", [`${service}/build`], {
-        stdio: "inherit",
-        shell: true,
-        cwd: projectRoot
-      });
-    }
-  }
+frappe.command("bench").description("run bench command").action(async () => {
+	const parentOptions = frappe.opts();
+	import_main.default.config({ path: parentOptions.dotenv || defaultDotenvPath });
+	await spawn("sh", [path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scripts/frappe.sh"), "bench"], {
+		stdio: "inherit",
+		shell: true,
+		cwd: projectRoot
+	});
 });
-program.command("test").argument(
-  "[args...]",
-  `test to run: ${[...availableServices, "packages"].join(", ")} (default: all)`
-).description("run test command").action(async (args) => {
-  args = args.flatMap((arg) => arg.split(","));
-  const packages = args.includes("packages");
-  const projects = args.filter((arg) => arg !== "packages");
-  if (!projects.length && !packages || packages) {
-    await execa(
-      "pnpm",
-      [
-        "turbo",
-        "run",
-        "test",
-        "--filter",
-        "'!./platforms/*'",
-        "--filter",
-        "'!./api'",
-        "--filter",
-        "'!./solana'",
-        "--filter",
-        "'!./ethereum'",
-        "--filter",
-        "'!./sui'"
-      ],
-      {
-        stdio: "inherit",
-        shell: true,
-        cwd: projectRoot
-      }
-    );
-  }
-  for (const platform of await fs.readdir("platforms")) {
-    if ((!projects.length && !packages || projects.includes(platform)) && await fs.access(path.join(projectRoot, "platforms", platform, "package.json")).then(
-      () => JSON.parse(
-        fsSync.readFileSync(
-          path.join(projectRoot, "platforms", platform, "package.json"),
-          "utf8"
-        )
-      ).scripts?.test
-    ).catch(() => false)) {
-      await execa("./mkpm", [`${platform}/test`], {
-        stdio: "inherit",
-        shell: true,
-        cwd: projectRoot
-      });
-    }
-  }
-  for (const service of availableServices) {
-    if ((!projects.length && !packages || projects.includes(service)) && await fs.access(path.join(projectRoot, service, "package.json")).then(
-      () => JSON.parse(
-        fsSync.readFileSync(
-          path.join(projectRoot, service, "package.json"),
-          "utf8"
-        )
-      ).scripts?.test
-    ).catch(() => false)) {
-      await execa("./mkpm", [`${service}/test`], {
-        stdio: "inherit",
-        shell: true,
-        cwd: projectRoot
-      });
-    }
-  }
+program.command("build").argument("[args...]", `build to run: ${[...availableServices, "packages"].join(", ")} (default: all)`).description("run build command").action(async (args) => {
+	const parsed = args.flatMap((arg) => arg.split(","));
+	const packages = parsed.includes("packages");
+	const projects = parsed.filter((arg) => arg !== "packages");
+	const presentApps = await getPresentApps(projectRoot);
+	const presentServices = await getPresentServices(projectRoot);
+	if (!projects.length && !packages || packages) await spawn("pnpm", [
+		"turbo",
+		"run",
+		"build",
+		"--filter",
+		"'!./apps/*'",
+		...presentServices.flatMap((s) => ["--filter", `'!./${serviceDir(s)}'`])
+	], {
+		stdio: "inherit",
+		shell: true,
+		cwd: projectRoot
+	});
+	for (const platform of presentApps) if (!projects.length && !packages || projects.includes(platform)) {
+		if (await fs.access(path.join(projectRoot, "apps", platform, "package.json")).then(() => JSON.parse(fsSync.readFileSync(path.join(projectRoot, "apps", platform, "package.json"), "utf8")).scripts?.build).catch(() => false)) await spawn("pnpm", [
+			"turbo",
+			"run",
+			"build",
+			`--filter=./apps/${platform}`
+		], {
+			stdio: "inherit",
+			shell: true,
+			cwd: projectRoot
+		});
+	}
+	for (const service of presentServices) if (!projects.length && !packages || projects.includes(service)) {
+		const dir = serviceDir(service);
+		if (await fs.access(path.join(projectRoot, dir, "package.json")).then(() => JSON.parse(fsSync.readFileSync(path.join(projectRoot, dir, "package.json"), "utf8")).scripts?.build).catch(() => false)) await spawn("pnpm", [
+			"turbo",
+			"run",
+			"build",
+			`--filter=./${dir}`
+		], {
+			stdio: "inherit",
+			shell: true,
+			cwd: projectRoot
+		});
+	}
+});
+program.command("test").argument("[args...]", "test to run: unit, integration, e2e, visual (default: unit)").option("--up-only", "start E2E environment and exit (for agent/manual testing)").option("--down", "tear down E2E test environment").option("--port-offset <number>", "port offset from defaults", "1000").option("--project <name>", "Docker project name for E2E").option("--no-build", "skip image builds for E2E").option("--filter <pattern>", "run specific Playwright test files").description("run test command").action(async (args, options) => {
+	const parsed = args.flatMap((arg) => arg.split(","));
+	if (parsed.includes("unit")) {
+		const excludeFilters = await getTurboExcludeFiltersForMissing(projectRoot);
+		const e2eApp = await discoverE2EApp(projectRoot);
+		await spawn("pnpm", [
+			"turbo",
+			"run",
+			"test",
+			...[...excludeFilters.flatMap((f) => ["--filter", f]), ...e2eApp ? ["--filter", `'!./apps/${e2eApp}'`] : []]
+		], {
+			stdio: "inherit",
+			shell: true,
+			cwd: projectRoot
+		});
+		const frappeApps = await getFrappeApps(projectRoot);
+		for (const app of frappeApps) if (await fs.access(path.join(app.absolutePath, "pyproject.toml")).then(() => true).catch(() => false)) try {
+			await spawn("bench", [
+				"run-tests",
+				"--app",
+				app.name,
+				"--",
+				"-m",
+				"not integration"
+			], {
+				stdio: "inherit",
+				cwd: path.join(projectRoot, "apps", "frappe")
+			});
+		} catch {
+			console.warn(`frappe app ${app.name} unit tests failed (bench may not be available)`);
+		}
+		if (parsed.length === 1) return;
+	}
+	if (parsed.includes("integration")) {
+		const excludeFilters = await getTurboExcludeFiltersForMissing(projectRoot);
+		const e2eApp = await discoverE2EApp(projectRoot);
+		await spawn("pnpm", [
+			"turbo",
+			"run",
+			"test",
+			...[...excludeFilters.flatMap((f) => ["--filter", f]), ...e2eApp ? ["--filter", `'!./apps/${e2eApp}'`] : []]
+		], {
+			stdio: "inherit",
+			shell: true,
+			cwd: projectRoot
+		});
+		const frappeApps = await getFrappeApps(projectRoot);
+		for (const app of frappeApps) if (await fs.access(path.join(app.absolutePath, "pyproject.toml")).then(() => true).catch(() => false)) try {
+			await spawn("bench", [
+				"run-tests",
+				"--app",
+				app.name,
+				"--",
+				"-m",
+				"integration"
+			], {
+				stdio: "inherit",
+				cwd: path.join(projectRoot, "apps", "frappe")
+			});
+		} catch {
+			console.warn(`frappe app ${app.name} integration tests failed (bench may not be available)`);
+		}
+		if (parsed.length === 1) return;
+	}
+	if (parsed.includes("e2e")) {
+		const teardownHandler = () => {
+			runE2ESession(projectRoot, { down: true }).then(() => process.exit(130));
+		};
+		if (!options.down) {
+			process.on("SIGINT", teardownHandler);
+			process.on("SIGTERM", teardownHandler);
+		}
+		await runE2ESession(projectRoot, {
+			upOnly: options.upOnly,
+			down: options.down,
+			portOffset: Number.parseInt(options.portOffset),
+			project: options.project,
+			noBuild: options.build === false,
+			filter: options.filter
+		});
+		return;
+	}
+	if (parsed.includes("visual")) {
+		const workspaces = await getStorybookVisualWorkspaces(projectRoot);
+		if (!workspaces.length) {
+			console.warn("No visual regression workspaces found (.storybook + Makefile test/visual, test:visual script, or lost-pixel).");
+			return;
+		}
+		for (const w of workspaces) if (w.runVisual === "make") await spawn("make", [
+			"-C",
+			w.absolutePath,
+			"test/visual"
+		], {
+			stdio: "inherit",
+			cwd: projectRoot
+		});
+		else if (w.runLostPixelAfterBuild) {
+			await spawn("pnpm", ["run", "build"], {
+				stdio: "inherit",
+				cwd: w.absolutePath
+			});
+			await spawn("pnpm", ["exec", "lost-pixel"], {
+				stdio: "inherit",
+				cwd: w.absolutePath
+			});
+		} else if (w.pnpmScript) await spawn("pnpm", ["run", w.pnpmScript], {
+			stdio: "inherit",
+			cwd: w.absolutePath
+		});
+		return;
+	}
+});
+/**
+* Run ruff format or check on the Frappe Python apps (if present).
+* Returns true if the ruff step failed.
+*/
+async function ruffStep(mode) {
+	const frappeApps = path.join(projectRoot, "apps", "frappe", "apps");
+	if (!fsSync.existsSync(frappeApps)) return false;
+	console.log(`\n── ${mode === "format" ? "ruff format" : "ruff check"} (Python) ──`);
+	try {
+		await spawn("ruff", [mode, frappeApps], {
+			stdio: "inherit",
+			cwd: projectRoot
+		});
+		return false;
+	} catch {
+		return true;
+	}
+}
+program.command("format").description("format all supported files (TS, Python, etc.) via turbo").action(async () => {
+	await spawn("turbo", [
+		"run",
+		"format",
+		"--filter=//"
+	], {
+		stdio: "inherit",
+		cwd: projectRoot
+	});
+	await ruffStep("format");
 });
-program.command("check").argument("[args...]", "checks to run: spelling, types, lint (default: all)").description("run check command").action(async (args) => {
-  args = args.flatMap((arg) => arg.split(","));
-  const spelling = !args.length || args.includes("spelling");
-  const types = !args.length || args.includes("types");
-  const lint = !args.length || args.includes("lint");
-  let exitCode = 0;
-  if (spelling) {
-    try {
-      await execa(
-        "pnpm",
-        [
-          "cspell",
-          "--unique",
-          "`(git ls-files && (git lfs ls-files | cut -d' ' -f3))`"
-        ],
-        {
-          stdio: "inherit",
-          shell: true,
-          cwd: projectRoot
-        }
-      );
-    } catch (err) {
-      if (err instanceof Error && "exitCode" in err) {
-        exitCode = err.exitCode;
-      } else {
-        exitCode = 1;
-      }
-    }
-  }
-  if (types) {
-    try {
-      await execa("turbo", ["run", "typecheck"], {
-        stdio: "inherit",
-        shell: true,
-        cwd: projectRoot
-      });
-    } catch (err) {
-      if (err instanceof Error && "exitCode" in err) {
-        exitCode = err.exitCode;
-      } else {
-        exitCode = 1;
-      }
-    }
-  }
-  if (lint) {
-    try {
-      await execa(
-        "pnpm",
-        [
-          "biome",
-          "check",
-          "--fix",
-          "--unsafe",
-          "`(git ls-files && (git lfs ls-files | cut -d' ' -f3)) | sort | uniq -u | grep -E '(html)|(s?css)|(md)|(json)|(yaml)|([jt]sx?)$'`"
-        ],
-        {
-          stdio: "inherit",
-          shell: true,
-          cwd: projectRoot
-        }
-      );
-    } catch (err) {
-      if (err instanceof Error && "exitCode" in err) {
-        exitCode = err.exitCode;
-      } else {
-        exitCode = 1;
-      }
-    }
-  }
-  process.exit(exitCode);
+program.command("lint").description("lint and typecheck all supported files (TS, Python, etc.) via turbo").action(async () => {
+	const excludeFilters = await getTurboExcludeFiltersForMissing(projectRoot);
+	let turboFailed = false;
+	try {
+		await spawn("turbo", [
+			"run",
+			"lint",
+			"typecheck",
+			"--filter=//",
+			"--continue",
+			"--filter",
+			"!@package/features",
+			...excludeFilters.flatMap((f) => ["--filter", f])
+		], {
+			stdio: "inherit",
+			cwd: projectRoot
+		});
+	} catch {
+		turboFailed = true;
+	}
+	const ruffFailed = await ruffStep("check");
+	if (turboFailed || ruffFailed) process.exit(1);
 });
 program.command("count").description("count lines of code").action(async () => {
-  await execa(
-    "cloc",
-    [
-      "`(git ls-files && (git lfs ls-files | cut -d' ' -f3)) | sort | uniq -u | grep -E '(html)|(s?css)|(md)|(json)|(yaml)|([jt]sx?)$'`"
-    ],
-    {
-      stdio: "inherit",
-      shell: true,
-      cwd: projectRoot
-    }
-  );
+	await spawn("cloc", ["`git ls-files | grep -E '(html)|(s?css)|(md)|(json)|(yaml)|([jt]sx?)$'`"], {
+		stdio: "inherit",
+		shell: true,
+		cwd: projectRoot
+	});
 });
 program.command("generate").description("run generate command").action(async () => {
-  await execa("pnpm", ["turbo", "run", "generate"], {
-    stdio: "inherit",
-    shell: true,
-    cwd: projectRoot
-  });
+	await spawn("pnpm", [
+		"turbo",
+		"run",
+		"generate"
+	], {
+		stdio: "inherit",
+		shell: true,
+		cwd: projectRoot
+	});
 });
 program.parse(process.argv);
 async function waitWithSpinner(services, options = {}) {
-  const { interval = 1e3, timeout = 6e5 } = options;
-  const waitFunctions = {
-    api: waitForApi,
-    frappe: waitForFrappe,
-    postgres: waitForPostgres,
-    keycloak: waitForKeycloak
-  };
-  const unreadyServices = [...services];
-  const spinner = ora(
-    `waiting for ${formatServiceList(unreadyServices)}`
-  ).start();
-  function updateSpinner(readyService) {
-    unreadyServices.splice(unreadyServices.indexOf(readyService), 1);
-    spinner.succeed(`${readyService} is ready`);
-    if (unreadyServices.length) {
-      spinner.start(`waiting for ${formatServiceList(unreadyServices)}`);
-    }
-  }
-  let timeoutId;
-  try {
-    await Promise.race([
-      Promise.all(
-        services.map(async (service) => {
-          const waitFn = waitFunctions[service];
-          if (!waitFn) throw new Error(`Unknown service: ${service}`);
-          await waitFn(interval);
-          updateSpinner(service);
-        })
-      ),
-      new Promise((_, reject) => {
-        timeoutId = setTimeout(() => reject(new Error("Timeout")), timeout);
-      })
-    ]);
-  } catch (err) {
-    const error = err;
-    if (error.message === "Timeout") {
-      spinner.fail(
-        `${formatServiceList(unreadyServices)} timed out after ${timeout}ms`
-      );
-    } else {
-      spinner.fail(error.message);
-    }
-    throw error;
-  } finally {
-    clearTimeout(timeoutId);
-  }
+	const { interval = 1e3, timeout = 6e5 } = options;
+	const waitFunctions = {
+		frappe: waitForFrappe,
+		postgres: waitForPostgres,
+		keycloak: waitForKeycloak
+	};
+	const unreadyServices = [...services];
+	const spinner = yoctoSpinner({ text: `waiting for ${formatServiceList(unreadyServices)}` }).start();
+	function updateSpinner(readyService) {
+		unreadyServices.splice(unreadyServices.indexOf(readyService), 1);
+		spinner.success(`${readyService} is ready`);
+		if (unreadyServices.length) spinner.start(`waiting for ${formatServiceList(unreadyServices)}`);
+	}
+	let timeoutId;
+	try {
+		await Promise.race([Promise.all(services.map(async (service) => {
+			const waitFn = waitFunctions[service];
+			if (!waitFn) throw new Error(`Unknown service: ${service}`);
+			await waitFn(interval);
+			updateSpinner(service);
+		})), new Promise((_, reject) => {
+			timeoutId = setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout")), timeout);
+		})]);
+	} catch (err) {
+		const error = err;
+		if (error.message === "Timeout") spinner.error(`${formatServiceList(unreadyServices)} timed out after ${timeout}ms`);
+		else spinner.error(error.message);
+		throw error;
+	} finally {
+		clearTimeout(timeoutId);
+	}
 }
+
+//#endregion
+export {  };