@multiplatform.one/cli 6.1.0 → 6.4.0

package/lib/commands/updateApp.mjs

@@ -0,0 +1,260 @@
+import { cliVersion, initApp, readProvenance, writeProvenance } from "./initApp.mjs";
+import { join } from "node:path";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import spawn from "nano-spawn";
+import { tmpdir } from "node:os";
+
+//#region src/commands/updateApp.ts
+/**
+* `mpo update` for scaffolded consumer projects — the modern successor of
+* the old cookiecutter flow (init a fresh project, swap your .git in, merge
+* your changes on top), rebuilt with a TRUE three-way merge:
+*
+*   base  = the ORIGINAL scaffold, regenerated from the CLI version recorded
+*           in .mpo.json at init time (published CLIs ship their templates,
+*           so `pnpm dlx @multiplatform.one/cli@<old> init` reproduces it)
+*   ours  = the project's HEAD (all your custom changes)
+*   theirs= a fresh scaffold from the CURRENT CLI version
+*
+* `git merge-tree --write-tree --merge-base=<base>` merges template
+* evolution with your customizations; conflicts land in the worktree with
+* normal conflict markers. An `.updateignore` file (one pathspec per line)
+* pins matching paths to your HEAD version, exactly like the old script.
+*/
+async function git(projectDir, args, env) {
+	return spawn("git", args, {
+		cwd: projectDir,
+		env: env ? {
+			...process.env,
+			...env
+		} : void 0
+	});
+}
+async function gitOut(projectDir, args, env) {
+	return (await git(projectDir, args, env)).stdout.trim();
+}
+/** Import a directory tree into the project's object database and return a
+*  root-less commit for it (temp index; the worktree is never touched). */
+async function commitTreeFromDir(projectDir, dir, message, parent) {
+	const indexFile = join(mkdtempSync(join(tmpdir(), "mpo-index-")), "index");
+	const env = {
+		GIT_INDEX_FILE: indexFile,
+		GIT_WORK_TREE: dir
+	};
+	await git(projectDir, [
+		"add",
+		"-A",
+		"--force",
+		"--",
+		"."
+	], env);
+	const tree = await gitOut(projectDir, ["write-tree"], env);
+	const commit = await gitOut(projectDir, parent ? [
+		"commit-tree",
+		tree,
+		"-p",
+		parent,
+		"-m",
+		message
+	] : [
+		"commit-tree",
+		tree,
+		"-m",
+		message
+	]);
+	rmSync(indexFile, { force: true });
+	return commit;
+}
+/** Scaffold a project with a specific published CLI version into tmp and
+*  return the generated project dir. Falls back to the local generator when
+*  the requested version matches the running CLI (or dlx fails). */
+async function scaffoldBaseline(version, name, template, mpoVersion) {
+	const parent = mkdtempSync(join(tmpdir(), "mpo-update-"));
+	const cleanup = () => rmSync(parent, {
+		recursive: true,
+		force: true
+	});
+	const current = cliVersion();
+	const templateFlag = template === "app" ? ["--web"] : ["--universal"];
+	if (version !== current) {
+		try {
+			await spawn("pnpm", [
+				"--package",
+				`@multiplatform.one/cli@${version}`,
+				"dlx",
+				"mpo",
+				"init",
+				name,
+				"--yes",
+				"--skip-install",
+				"--mpo-version",
+				mpoVersion,
+				...templateFlag
+			], {
+				cwd: parent,
+				stdio: "inherit"
+			});
+			const dir = join(parent, name);
+			if (existsSync(join(dir, "package.json"))) return {
+				dir,
+				cleanup
+			};
+			console.warn(`⚠️  dlx scaffold for @multiplatform.one/cli@${version} produced no project;`);
+		} catch {
+			console.warn(`⚠️  could not scaffold baseline with @multiplatform.one/cli@${version} (network?);`);
+		}
+		console.warn("   falling back to the current CLI's template as the merge base.");
+	}
+	const previousCwd = process.cwd();
+	process.chdir(parent);
+	try {
+		await initApp(name, {
+			skipInstall: true,
+			yes: true,
+			template,
+			version: mpoVersion
+		});
+	} finally {
+		process.chdir(previousCwd);
+	}
+	return {
+		dir: join(parent, name),
+		cleanup
+	};
+}
+async function updateApp(options = {}) {
+	const projectDir = await gitOut(process.cwd(), ["rev-parse", "--show-toplevel"]).catch(() => {
+		throw new Error("mpo update must run inside a git repository");
+	});
+	await git(projectDir, ["diff", "--quiet"]).catch(() => {
+		throw new Error("mpo update requires a clean working tree (unstaged changes present)");
+	});
+	await git(projectDir, [
+		"diff",
+		"--cached",
+		"--quiet"
+	]).catch(() => {
+		throw new Error("mpo update requires a clean working tree (staged changes present)");
+	});
+	const provenance = readProvenance(projectDir);
+	if (!provenance) throw new Error(".mpo.json not found — this project predates scaffold provenance. Create it with { template, cliVersion, name } matching how the project was generated (cliVersion = the @multiplatform.one/cli that scaffolded it), then re-run `mpo update`.");
+	const currentVersion = cliVersion() ?? "0.0.0";
+	const targetMpoRange = options.version ? options.version.startsWith("^") || options.version.startsWith("~") ? options.version : `^${options.version}` : `^${currentVersion}`;
+	console.log(`\nmpo update: ${provenance.cliVersion} → ${currentVersion}`);
+	console.log(`  template: ${provenance.template}`);
+	console.log(`  project:  ${provenance.name}\n`);
+	console.log(`Scaffolding merge base (cli@${provenance.cliVersion})...`);
+	const base = await scaffoldBaseline(provenance.cliVersion, provenance.name, provenance.template, provenance.mpoVersion);
+	console.log(`Scaffolding update target (cli@${currentVersion})...`);
+	const next = await scaffoldBaseline(currentVersion, provenance.name, provenance.template, targetMpoRange);
+	writeProvenance(next.dir, {
+		template: provenance.template,
+		cliVersion: currentVersion,
+		name: provenance.name,
+		mpoVersion: targetMpoRange
+	});
+	try {
+		const head = await gitOut(projectDir, ["rev-parse", "HEAD"]);
+		const baseCommit = await commitTreeFromDir(projectDir, base.dir, `mpo scaffold ${provenance.template}@${provenance.cliVersion}`);
+		const nextCommit = await commitTreeFromDir(projectDir, next.dir, `mpo scaffold ${provenance.template}@${currentVersion}`, baseCommit);
+		let mergedTree;
+		let conflicts = [];
+		try {
+			mergedTree = (await gitOut(projectDir, [
+				"merge-tree",
+				"--write-tree",
+				"--name-only",
+				`--merge-base=${baseCommit}`,
+				head,
+				nextCommit
+			])).split("\n")[0].trim();
+		} catch (err) {
+			const lines = (err.stdout ?? "").split("\n").filter(Boolean);
+			if (!lines.length) throw err;
+			mergedTree = lines[0].trim();
+			conflicts = lines.slice(1).map((line) => line.trim());
+		}
+		const finalProvenance = {
+			template: provenance.template,
+			cliVersion: currentVersion,
+			name: provenance.name,
+			mpoVersion: targetMpoRange
+		};
+		if (!conflicts.length) {
+			const message = `chore: mpo update ${provenance.cliVersion} → ${currentVersion}`;
+			await git(projectDir, [
+				"update-ref",
+				"HEAD",
+				await gitOut(projectDir, [
+					"commit-tree",
+					mergedTree,
+					"-p",
+					head,
+					"-p",
+					nextCommit,
+					"-m",
+					message
+				])
+			]);
+			await git(projectDir, [
+				"reset",
+				"--hard",
+				"HEAD"
+			]);
+			writeProvenance(projectDir, finalProvenance);
+			await git(projectDir, [
+				"add",
+				"--",
+				".mpo.json"
+			]);
+			await git(projectDir, [
+				"commit",
+				"--amend",
+				"--no-edit",
+				"--quiet"
+			]);
+			const amended = await gitOut(projectDir, [
+				"rev-parse",
+				"--short",
+				"HEAD"
+			]);
+			console.log(`\n✅ merged cleanly → ${amended} ("${message}")`);
+		} else {
+			await git(projectDir, [
+				"read-tree",
+				"-u",
+				"--reset",
+				mergedTree
+			]);
+			writeProvenance(projectDir, finalProvenance);
+			console.log("\n⚠️  merge conflicts — resolve the markers, then commit:");
+			for (const file of conflicts) console.log(`   ${file}`);
+			console.log(`\n   git add -A && git commit -m "chore: mpo update ${provenance.cliVersion} → ${currentVersion}"`);
+		}
+		const pins = ["pnpm-lock.yaml"];
+		const updateignore = join(projectDir, ".updateignore");
+		if (existsSync(updateignore)) for (const line of readFileSync(updateignore, "utf-8").split("\n")) {
+			const pattern = line.trim();
+			if (pattern && !pattern.startsWith("#")) pins.push(pattern);
+		}
+		for (const pin of pins) await git(projectDir, [
+			"checkout",
+			head,
+			"--",
+			pin
+		]).catch(() => {});
+		if (!options.skipInstall) {
+			console.log("\nInstalling dependencies...");
+			await spawn("pnpm", ["install"], {
+				cwd: projectDir,
+				stdio: "inherit"
+			});
+		}
+	} finally {
+		base.cleanup();
+		next.cleanup();
+	}
+}
+
+//#endregion
+export { updateApp };

package/lib/generateVscode.mjs

@@ -41,14 +41,30 @@ function launchConfigForApp(app) {
 	const { name, path: relPath, scripts } = app;
 	const configs = [];
 	const wf = "${workspaceFolder}";
-	if (name === "vscode" && scripts.dev) configs.push({
-		name: "vscode dev",
-		type: "extensionHost",
+	if (scripts["dev:vscode"]) {
+		configs.push({
+			name: "vscode dev",
+			type: "extensionHost",
+			request: "launch",
+			args: ["--disable-extensions", `--extensionDevelopmentPath=${wf}/${relPath}/dist-vscode`],
+			cwd: `${wf}/${relPath}`,
+			outFiles: [`${wf}/${relPath}/dist-vscode/extension/*.js`],
+			preLaunchTask: "npm: dev:vscode"
+		});
+		configs.push({
+			name: "vscode dev",
+			type: "node-terminal",
+			request: "launch",
+			cwd: `${wf}/${relPath}`,
+			command: "pnpm dev:vscode"
+		});
+	}
+	if (scripts["dev:webext"]) configs.push({
+		name: "webext dev",
+		type: "node-terminal",
 		request: "launch",
-		args: ["--disable-extensions", `--extensionDevelopmentPath=${wf}/${relPath}`],
 		cwd: `${wf}/${relPath}`,
-		outFiles: [`${wf}/${relPath}/dist/extension/*.js`],
-		preLaunchTask: "npm: dev"
+		command: "pnpm dev:webext"
 	});
 	if (scripts.dev) configs.push({
 		name: `${name} dev`,
@@ -117,12 +133,13 @@ async function generateLaunchJson(root) {
 	};
 }
 async function generateTasksJson(apps) {
-	if (!apps.find((a) => a.name === "vscode")?.scripts?.dev) return null;
+	const hostApp = apps.find((a) => a.scripts?.["dev:vscode"]);
+	if (!hostApp) return null;
 	return {
 		version: "2.0.0",
 		tasks: [{
 			type: "npm",
-			script: "dev",
+			script: "dev:vscode",
 			problemMatcher: {
 				owner: "typescript",
 				fileLocation: "relative",
@@ -146,7 +163,7 @@ async function generateTasksJson(apps) {
 				kind: "build",
 				isDefault: true
 			},
-			options: { cwd: "${workspaceFolder}/apps/vscode" }
+			options: { cwd: `\${workspaceFolder}/${hostApp.path}` }
 		}]
 	};
 }
@@ -160,7 +177,7 @@ async function generateVscodeConfig(root) {
 	if (tasks) {
 		await fs.writeFile(path.join(vsCodeDir, "tasks.json"), JSON.stringify(tasks, null, 2), "utf8");
 		console.log("Wrote .vscode/tasks.json");
-	} else console.log("Skipped .vscode/tasks.json (no apps/vscode with dev script)");
+	} else console.log("Skipped .vscode/tasks.json (no app with a dev:vscode script)");
 }
 
 //#endregion

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@multiplatform.one/cli",
-  "version": "6.1.0",
-  "description": "multiplatform.one cli",
-  "keywords": [],
+  "version": "6.4.0",
+  "description": "multiplatform.one cli — mpo init / create-multiplatform-app",
+  "keywords": [
+    "create-multiplatform-app",
+    "mpo",
+    "multiplatform.one",
+    "scaffold"
+  ],
   "bugs": {
     "url": "https://gitlab.com/bitspur/multiplatform.one/multiplatform.one/issues"
   },
@@ -16,9 +21,11 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://gitlab.com/bitspur/multiplatform.one/multiplatform.one.git"
+    "url": "git+https://gitlab.com/bitspur/frappe/multiplatform.one.git",
+    "directory": "public/cli"
   },
   "bin": {
+    "create-multiplatform-app": "./bin/createMultiplatformApp.mjs",
     "mpo": "./bin/multiplatformOne.mjs"
   },
   "source": "src/index.ts",
@@ -27,19 +34,21 @@
     "lib",
     "scripts",
     "src",
-    "types"
+    "templates",
+    "types",
+    "!types/.tsbuildinfo"
   ],
   "type": "module",
   "module": "lib/index.mjs",
   "types": "types/index.d.ts",
   "exports": {
     ".": {
-      "import": "./lib/index.mjs",
-      "types": "./types/index.d.ts"
+      "types": "./types/index.d.ts",
+      "import": "./lib/index.mjs"
     },
     "./bin/multiplatformOne": {
-      "import": "./lib/bin/multiplatformOne.mjs",
-      "types": "./types/bin/multiplatformOne.d.ts"
+      "types": "./types/bin/multiplatformOne.d.ts",
+      "import": "./lib/bin/multiplatformOne.mjs"
     },
     "./package.json": "./package.json"
   },
@@ -52,18 +61,20 @@
     "nano-spawn": "^2.1.0",
     "yaml": "^2.8.3",
     "yocto-spinner": "^1.1.0",
-    "@multiplatform.one/utils": "6.1.0"
+    "@multiplatform.one/utils": "6.4.0"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.6.0",
-    "typescript": "~5.9.3"
+    "typescript": "~5.9.3",
+    "vitest": "^4.1.5"
   },
   "engines": {
     "node": ">= 16.0"
   },
   "scripts": {
-    "build": "rm -rf lib types 2>/dev/null && tsc -b --emitDeclarationOnly && tsdown",
+    "build": "rm -rf lib types 2>/dev/null && tsc -p tsconfig.build.json && tsdown",
+    "test": "vitest run",
     "typecheck": "tsc --noEmit"
   }
 }

package/src/bin/multiplatformOne.ts

@@ -19,6 +19,8 @@ import YAML from "yaml";
 import yoctoSpinner from "yocto-spinner";
 import { discoverE2EApp, runE2ESession } from "../commands/e2e";
 import { init, runModifyStep } from "../commands/init";
+import { initApp, readProvenance } from "../commands/initApp";
+import { updateApp } from "../commands/updateApp";
 
 const projectRoot = lookupProjectRoot();
 const availableServices = ["api", "frappe", "solana", "ethereum", "sui"];
@@ -216,35 +218,84 @@ program.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")
+  .option("--universal", "scaffold the universal template (web + iOS + Android; default)")
+  .option("--web", "scaffold the web-only template (Vite + React)")
+  .option("--app", "alias of --web (back-compat)")
+  .option("--skip-install", "skip pnpm install after scaffolding")
+  .option(
+    "--mpo-version <range>",
+    "semver range for @multiplatform.one/* (default: ^<cli version>)",
+  )
+  .option("-y, --yes", "non-interactive: accept defaults instead of prompting")
+  .option(
+    "--monorepo",
+    "DEPRECATED: clone/modify the full multiplatform.one monorepo instead of scaffolding a consumer project",
+  )
+  .option("-c, --checkout <branch>", "branch, tag or commit to checkout (--monorepo only)", "main")
+  .option("-a, --apps <apps>", "comma-separated apps to include (--monorepo only)")
+  .option("-s, --services <services>", "comma-separated services to include (--monorepo only)")
   .argument("[name]", "the name of the project")
-  .description("clone multiplatform.one and apply selected apps/services")
+  .description(
+    "scaffold a new multiplatform project (universal web + native by default; --web for web-only; semver @multiplatform.one/* deps)",
+  )
   .action(async (name: string | undefined, 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");
+    if (options.monorepo) {
+      console.warn(
+        "⚠️  `mpo init --monorepo` clones the whole multiplatform.one monorepo (legacy). " +
+          "New projects should use the default consumer scaffold instead.",
+      );
+      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 });
+      return;
     }
-    const cloneScript = path.resolve(
-      path.dirname(fileURLToPath(import.meta.url)),
-      "../../scripts/clone.sh",
-    );
-    await init(name, { ...options, cloneScript });
+    if (options.apps || options.services) {
+      throw new Error(
+        "--apps/--services select monorepo pieces and require --monorepo (legacy clone mode)",
+      );
+    }
+    const webOnly = Boolean(options.web || options.app);
+    if (webOnly && options.universal) {
+      throw new Error("Pass either --web/--app or --universal, not both");
+    }
+    await initApp(name, {
+      skipInstall: Boolean(options.skipInstall),
+      version: options.mpoVersion,
+      template: webOnly ? "app" : options.universal ? "universal" : undefined,
+      yes: Boolean(options.yes),
+    });
   });
 
 const defaultUpdateRemote = "https://gitlab.com/bitspur/multiplatform.one/multiplatform.one.git";
 
 program
   .command("update")
-  .option("-c, --checkout <branch>", "branch, tag or commit to merge from upstream", "main")
-  .option("-r, --remote <url>", "upstream remote URL", defaultUpdateRemote)
-  .description("merge upstream and re-apply workspace config")
-  .action(async (options: { checkout: string; remote: string }) => {
+  .option("-c, --checkout <branch>", "branch, tag or commit to merge from upstream (monorepo forks)", "main")
+  .option("-r, --remote <url>", "upstream remote URL (monorepo forks)", defaultUpdateRemote)
+  .option("--skip-install", "skip pnpm install after the update")
+  .option(
+    "--mpo-version <range>",
+    "semver range for @multiplatform.one/* (default: ^<cli version>)",
+  )
+  .description(
+    "update a scaffolded project to the current template (three-way merge via .mpo.json provenance); monorepo forks fall back to the upstream merge flow",
+  )
+  .action(async (options: {
+    checkout: string;
+    remote: string;
+    skipInstall?: boolean;
+    mpoVersion?: string;
+  }) => {
     // Update prechecks: must be in a git repo
     if (
       await spawn("git", ["rev-parse", "--is-inside-work-tree"]).then(
@@ -254,6 +305,18 @@ program
     ) {
       throw new Error("mpo cannot be updated outside of a git repository");
     }
+    // Scaffolded consumer projects carry .mpo.json provenance — use the
+    // copier-style three-way template update. Monorepo forks fall through to
+    // the legacy upstream-merge flow below.
+    if (readProvenance(projectRoot)) {
+      await updateApp({ skipInstall: options.skipInstall, version: options.mpoVersion });
+      try {
+        await generateVscodeConfig(projectRoot);
+      } catch {
+        // best-effort
+      }
+      return;
+    }
     // Require clean working tree (no staged or unstaged changes)
     if (
       await spawn("git", ["diff", "--cached", "--quiet"]).then(

package/src/commands/init.ts

@@ -11,15 +11,10 @@ const services = ["frappe", "solana", "ethereum", "sui"] as const;
 function serviceDir(name: string): string {
   return `apps/${name}`;
 }
-const apps = [
-  "one",
-  "keycloak",
-  "storybook",
-  "storybook-expo",
-  "vscode",
-  "webext",
-  "vocs",
-] as const;
+// vscode + webext are no longer standalone apps: they are delivery targets
+// of the One platform app (apps/one/vscode, apps/one/webext) and ride with
+// the "one" selection.
+const apps = ["one", "keycloak", "storybook", "storybook-expo", "vocs"] as const;
 
 type Service = (typeof services)[number];
 type App = (typeof apps)[number];
@@ -34,12 +29,10 @@ const serviceEnvPrefixes: Record<Service, string[]> = {
 
 /** env variable prefixes to remove per app */
 const appEnvPrefixes: Record<App, string[]> = {
-  one: ["ONE_"],
+  one: ["ONE_", "VSCODE_", "WEBEXT_"],
   keycloak: ["KEYCLOAK_"],
   storybook: ["STORYBOOK_", "VR_DIFFING_ENGINE="],
   "storybook-expo": [],
-  vscode: ["VSCODE_"],
-  webext: ["WEBEXT_"],
   vocs: ["VOCS_"],
 };
 
@@ -52,12 +45,10 @@ const serviceEnvSections: Record<Service, string[]> = {
 };
 
 const appEnvSections: Record<App, string[]> = {
-  one: ["# one"],
+  one: ["# one", "# vscode", "# webext"],
   keycloak: ["# keycloak"],
   storybook: ["# storybook"],
   "storybook-expo": [],
-  vscode: ["# vscode"],
-  webext: ["# webext"],
   vocs: ["# vocs"],
 };
 
@@ -70,12 +61,10 @@ const serviceLaunchNames: Record<Service, string[]> = {
 };
 
 const appLaunchNames: Record<App, string[]> = {
-  one: ["one dev"],
+  one: ["one dev", "vscode dev", "webext dev"],
   keycloak: ["keycloak dev", "keycloak storybook"],
   storybook: ["storybook dev"],
   "storybook-expo": ["storybook-expo dev"],
-  vscode: ["vscode dev"],
-  webext: ["webext dev"],
   vocs: ["vocs dev"],
 };