@multiplatform.one/cli 6.4.3 → 6.6.0

package/src/bin/multiplatformOne.ts

@@ -19,7 +19,7 @@ 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 { INIT_APP_PIECES, initApp, readProvenance } from "../commands/initApp";
 import { updateApp } from "../commands/updateApp";
 
 const projectRoot = lookupProjectRoot();
@@ -221,6 +221,15 @@ program
   .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("--frappe", "add the Frappe backend piece (env keys, provider, docker compose bench)")
+  .option("--keycloak", "add the Keycloak auth piece (env keys, provider, docker compose + realm)")
+  .option(
+    "--gnome",
+    "add the GNOME desktop target piece (GTK4/GJS via react-gnome — native widgets, no webview)",
+  )
+  .option("--tauri", "add the desktop target piece (src-tauri skeleton, webview)")
+  .option("--vscode", "add the VS Code extension target piece")
+  .option("--webext", "add the browser extension target piece (MV3 popup + background)")
   .option("--skip-install", "skip pnpm install after scaffolding")
   .option("--skip-git", "skip git init + scaffold commit")
   .option(
@@ -269,12 +278,16 @@ program
     if (webOnly && options.universal) {
       throw new Error("Pass either --web/--app or --universal, not both");
     }
+    // Piece flags are multi-select; passing any of them skips the interactive
+    // pieces prompt. No flags + --yes (or non-TTY) → no pieces.
+    const pieces = INIT_APP_PIECES.filter((piece) => Boolean(options[piece]));
     await initApp(name, {
       skipInstall: Boolean(options.skipInstall),
       skipGit: Boolean(options.skipGit),
       version: options.mpoVersion,
       template: webOnly ? "app" : options.universal ? "universal" : undefined,
       yes: Boolean(options.yes),
+      pieces: pieces.length ? pieces : undefined,
     });
   });
 

package/src/commands/initApp.spec.ts

@@ -1,8 +1,16 @@
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { extname, join } from "node:path";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { initApp } from "./initApp";
+import { initApp, mergeJsonValues, readProvenance } from "./initApp";
 
 const readJson = (path: string) => JSON.parse(readFileSync(path, "utf-8"));
 
@@ -207,4 +215,362 @@ describe("initApp generator", () => {
       initApp("occupied", { template: "app", skipInstall: true, yes: true }),
     ).rejects.toThrow(/already exists and is not empty/u);
   });
+
+  describe("composable pieces", () => {
+    describe("webext piece", () => {
+      const name = "ext-demo";
+      let root: string;
+
+      beforeAll(async () => {
+        await initApp(name, {
+          template: "universal",
+          skipInstall: true,
+          skipGit: true,
+          version: "6.1.0",
+          yes: true,
+          pieces: ["webext"],
+        });
+        root = join(sandbox, name);
+      });
+
+      it("overlays the webext target files", () => {
+        for (const file of [
+          `apps/${name}/vite.config.webext.ts`,
+          `apps/${name}/vite.config.webext-background.ts`,
+          `apps/${name}/webext/env.ts`,
+          `apps/${name}/webext/manifest.ts`,
+          `apps/${name}/webext/prepare.ts`,
+          `apps/${name}/webext/tamagui.css`,
+          `apps/${name}/webext/tsconfig.json`,
+          `apps/${name}/webext/background/main.ts`,
+          `apps/${name}/webext/components/ErrorBoundary.tsx`,
+          `apps/${name}/webext/views/popup/index.html`,
+          `apps/${name}/webext/views/popup/main.tsx`,
+          `apps/${name}/webext/assets/fonts/inter-400.woff2`,
+          `apps/${name}/webext/assets/fonts/inter-700.woff2`,
+          `apps/${name}/webext/static/assets/icon-512.png`,
+        ]) {
+          expect(existsSync(join(root, file)), `missing ${file}`).toBe(true);
+        }
+      });
+
+      it("renders template vars in fragment files", () => {
+        const manifest = readFileSync(join(root, `apps/${name}/webext/manifest.ts`), "utf-8");
+        expect(manifest).toContain('const DISPLAY_NAME = "ExtDemo"');
+        for (const file of [
+          `apps/${name}/vite.config.webext.ts`,
+          `apps/${name}/webext/manifest.ts`,
+          `apps/${name}/webext/views/popup/main.tsx`,
+        ]) {
+          expect(readFileSync(join(root, file), "utf-8")).not.toMatch(/__NAME(_PASCAL|_APPID)?__/u);
+        }
+        const popup = readFileSync(join(root, `apps/${name}/webext/views/popup/main.tsx`), "utf-8");
+        expect(popup).toContain(`from "@features/${name}"`);
+      });
+
+      it("deep-merges package.json.partial into the app manifest", () => {
+        const appPkg = readJson(join(root, `apps/${name}/package.json`));
+        // base scripts survive, fragment scripts append
+        expect(appPkg.scripts.dev).toContain("one dev");
+        expect(appPkg.scripts["build:webext"]).toContain("vite.config.webext.ts");
+        expect(appPkg.scripts["typecheck:webext"]).toBe("tsc --noEmit -p webext/tsconfig.json");
+        // fragment deps merge in with rendered versions; base deps survive
+        expect(appPkg.dependencies["webextension-polyfill"]).toBe("^0.12.0");
+        expect(appPkg.dependencies["@multiplatform.one/router"]).toBe("^6.1.0");
+        expect(appPkg.dependencies[`@features/${name}`]).toBe("workspace:*");
+        expect(appPkg.devDependencies["@multiplatform.one/vite-plugin-webext"]).toBe("^6.1.0");
+        // dependency maps stay sorted after the merge
+        for (const field of ["dependencies", "devDependencies"]) {
+          const keys = Object.keys(appPkg[field]);
+          expect(keys, `${field} sorted`).toEqual([...keys].sort());
+        }
+      });
+
+      it("unions tsconfig types and root scripts, appends gitignore", () => {
+        const tsconfig = readJson(join(root, `apps/${name}/tsconfig.json`));
+        expect(tsconfig.compilerOptions.types).toEqual(["vite/client", "node"]);
+        const rootPkg = readJson(join(root, "package.json"));
+        expect(rootPkg.scripts["build:webext"]).toBe(`pnpm --filter @app/${name} build:webext`);
+        const gitignore = readFileSync(join(root, ".gitignore"), "utf-8");
+        expect(gitignore).toContain("node_modules");
+        expect(gitignore).toContain("dist-webext");
+      });
+
+      it("records pieces in provenance", () => {
+        const provenance = readJson(join(root, ".mpo.json"));
+        expect(provenance.pieces).toEqual(["webext"]);
+        expect(readProvenance(root)?.pieces).toEqual(["webext"]);
+      });
+    });
+
+    describe("frappe + keycloak pieces", () => {
+      const name = "backend-demo";
+      let root: string;
+
+      beforeAll(async () => {
+        await initApp(name, {
+          template: "universal",
+          skipInstall: true,
+          skipGit: true,
+          version: "6.1.0",
+          yes: true,
+          // intentionally unsorted — provenance must sort
+          pieces: ["keycloak", "frappe"],
+        });
+        root = join(sandbox, name);
+      });
+
+      it("generates src/app.ts from the selected providers", () => {
+        const appTs = readFileSync(join(root, `apps/${name}/src/app.ts`), "utf-8");
+        expect(appTs).toContain('import { config } from "@multiplatform.one/platform"');
+        expect(appTs).toContain('frappe: { baseURL: config.get("FRAPPE_URL") }');
+        expect(appTs).toContain('keycloak: { baseUrl: config.get("KEYCLOAK_BASE_URL") }');
+        expect(appTs).toContain("theme: themeConfig");
+      });
+
+      it("accumulates public config keys across pieces", () => {
+        const config = readJson(join(root, "packages/config/config.json"));
+        expect(config.public).toEqual([
+          "BASE_URL",
+          "DEBUG",
+          "I18N_DEFAULT_LANGUAGE",
+          "FRAPPE_ENABLED",
+          "FRAPPE_URL",
+          "KEYCLOAK_ENABLED",
+          "KEYCLOAK_BASE_URL",
+          "KEYCLOAK_REALM",
+          "KEYCLOAK_CLIENT_ID",
+          "KEYCLOAK_PUBLIC_CLIENT_ID",
+        ]);
+        expect(config.private).toEqual(["SECRET"]);
+      });
+
+      it("writes env, docker, and README fragments", () => {
+        const env = readFileSync(join(root, ".env.example"), "utf-8");
+        expect(env).toContain("FRAPPE_ENABLED=1");
+        expect(env).toContain("KEYCLOAK_ENABLED=1");
+        expect(env).toContain(`KEYCLOAK_REALM=${name}`);
+        expect(existsSync(join(root, "docker/compose.frappe.yaml"))).toBe(true);
+        expect(existsSync(join(root, "docker/compose.keycloak.yaml"))).toBe(true);
+        const realm = readJson(join(root, "docker/keycloak/realm.json"));
+        expect(realm.realm).toBe(name);
+        expect(realm.clients[1].clientId).toBe(`${name}-public`);
+        const readme = readFileSync(join(root, "README.md"), "utf-8");
+        expect(readme).toContain("## Frappe backend");
+        expect(readme).toContain("## Keycloak auth");
+      });
+
+      it("records pieces sorted in provenance", () => {
+        expect(readJson(join(root, ".mpo.json")).pieces).toEqual(["frappe", "keycloak"]);
+      });
+    });
+
+    describe("kitchen sink (all pieces)", () => {
+      const name = "full-demo";
+      let root: string;
+
+      beforeAll(async () => {
+        await initApp(name, {
+          template: "universal",
+          skipInstall: true,
+          skipGit: true,
+          version: "6.1.0",
+          yes: true,
+          pieces: ["frappe", "gnome", "keycloak", "tauri", "vscode", "webext"],
+        });
+        root = join(sandbox, name);
+      });
+
+      it("overlays every target", () => {
+        for (const file of [
+          `apps/${name}/vite.config.gnome.ts`,
+          `apps/${name}/gnome/main.tsx`,
+          `apps/${name}/gnome/polyfills.ts`,
+          `apps/${name}/gnome/tamagui-barrel.ts`,
+          `apps/${name}/gnome/shims/components.ts`,
+          `apps/${name}/gnome/shims/theme.ts`,
+          `apps/${name}/gnome/shims/forms.ts`,
+          `apps/${name}/gnome/shims/one.ts`,
+          `apps/${name}/gnome/shims/empty-module.ts`,
+          `apps/${name}/src-tauri/tauri.conf.json`,
+          `apps/${name}/src-tauri/Cargo.toml`,
+          `apps/${name}/src-tauri/src/main.rs`,
+          `apps/${name}/src-tauri/src/lib.rs`,
+          `apps/${name}/src-tauri/capabilities/default.json`,
+          `apps/${name}/src-tauri/icons/icon.icns`,
+          `apps/${name}/vite.config.vscode.ts`,
+          `apps/${name}/vscode/extension/index.ts`,
+          `apps/${name}/vscode/webview/main.tsx`,
+          `apps/${name}/vscode/webview/router.tsx`,
+          `apps/${name}/vscode/package.json`,
+          `apps/${name}/vscode/manifest.ts`,
+          `apps/${name}/vite.config.webext.ts`,
+          `apps/${name}/webext/manifest.ts`,
+          "docker/compose.frappe.yaml",
+          "docker/compose.keycloak.yaml",
+        ]) {
+          expect(existsSync(join(root, file)), `missing ${file}`).toBe(true);
+        }
+        const tauriConf = readJson(join(root, `apps/${name}/src-tauri/tauri.conf.json`));
+        expect(tauriConf.productName).toBe(name);
+        expect(tauriConf.identifier).toBe("com.fulldemo.app");
+        const rootPkg = readJson(join(root, "package.json"));
+        for (const script of [
+          "gnome",
+          "gnome:capture",
+          "tauri:dev",
+          "tauri:build",
+          "build:vscode",
+          "build:webext",
+        ]) {
+          expect(rootPkg.scripts[script], `root script ${script}`).toBeDefined();
+        }
+      });
+
+      // The GNOME target is the only piece that rewires module resolution
+      // rather than just adding files, and both halves of that rewiring
+      // fail silently if they drift. A shim that imports the bare barrel
+      // it is aliased FROM resolves back to itself — an infinite alias
+      // loop that surfaces as an out-of-memory bundler, not an import
+      // error. And the react-gnome packages are the runtime: without them
+      // the entry resolves nothing at all.
+      it("wires the gnome target without aliasing a shim back to itself", () => {
+        const aliased = ["components", "theme", "forms"] as const;
+        for (const barrel of aliased) {
+          const shim = readFileSync(join(root, `apps/${name}/gnome/shims/${barrel}.ts`), "utf-8");
+          expect(shim, `${barrel} shim must deep-import, never the bare barrel`).not.toMatch(
+            new RegExp(String.raw`from "@multiplatform\.one/${barrel}"`, "u"),
+          );
+          expect(shim, `${barrel} shim reaches its subgraph`).toMatch(
+            new RegExp(String.raw`@multiplatform\.one/${barrel}/src/`, "u"),
+          );
+        }
+        const appPkg = readJson(join(root, `apps/${name}/package.json`));
+        for (const dep of [
+          "@react-gnome/renderer",
+          "@react-gnome/react-native",
+          "@react-gnome/animation",
+          "@react-gnome/tamagui",
+        ]) {
+          expect(appPkg.dependencies[dep], `runtime dep ${dep}`).toBeDefined();
+        }
+        expect(appPkg.devDependencies["@react-gnome/vite-plugin"]).toBeDefined();
+        expect(appPkg.devDependencies["@multiplatform.one/vite-plugin-gnome"]).toBeDefined();
+        // polyfills must be the FIRST import: the globals have to exist
+        // before any hoisted module initializer probes for them.
+        const entry = readFileSync(join(root, `apps/${name}/gnome/main.tsx`), "utf-8");
+        const firstImport = entry.split("\n").find((line) => line.startsWith("import "));
+        expect(firstImport).toBe(`import "./polyfills";`);
+      });
+
+      it("leaves no template placeholders anywhere", () => {
+        const binary = new Set([".woff2", ".png", ".ico", ".icns"]);
+        const walk = (dir: string): string[] =>
+          readdirSync(dir).flatMap((entry) => {
+            const path = join(dir, entry);
+            if (statSync(path).isDirectory()) return walk(path);
+            return [path];
+          });
+        for (const file of walk(root)) {
+          if (binary.has(extname(file).toLowerCase())) continue;
+          expect(readFileSync(file, "utf-8"), `placeholder left in ${file}`).not.toMatch(
+            /__NAME(_PASCAL|_APPID)?__|__MPO_VERSION__|__YEAR__/u,
+          );
+        }
+      });
+
+      it("scaffolds deterministically (update baselines depend on it)", async () => {
+        // Same name in a different parent dir (paths and rendered content
+        // embed the project name); pieces passed in a different order.
+        const parent = mkdtempSync(join(tmpdir(), "mpo-again-"));
+        const cwd = process.cwd();
+        process.chdir(parent);
+        try {
+          await initApp(name, {
+            template: "universal",
+            skipInstall: true,
+            skipGit: true,
+            version: "6.1.0",
+            yes: true,
+            pieces: ["webext", "vscode", "tauri", "keycloak", "gnome", "frappe"],
+          });
+        } finally {
+          process.chdir(cwd);
+        }
+        const other = join(parent, name);
+        const rel = (dir: string, base: string): string[] =>
+          readdirSync(dir).flatMap((entry) => {
+            const path = join(dir, entry);
+            if (statSync(path).isDirectory()) return rel(path, base);
+            return [path.slice(base.length + 1)];
+          });
+        const ours = rel(root, root).sort();
+        expect(rel(other, other).sort()).toEqual(ours);
+        for (const file of ours) {
+          const a = readFileSync(join(root, file));
+          const b = readFileSync(join(other, file));
+          expect(b.equals(a), `content differs for ${file}`).toBe(true);
+        }
+        rmSync(parent, { recursive: true, force: true });
+      });
+    });
+
+    it("rejects pieces on the web-only template", async () => {
+      await expect(
+        initApp("web-pieces", {
+          template: "app",
+          skipInstall: true,
+          skipGit: true,
+          yes: true,
+          pieces: ["webext"],
+        }),
+      ).rejects.toThrow(/not available for the app template/u);
+    });
+
+    it("rejects unknown pieces", async () => {
+      await expect(
+        initApp("bogus-pieces", {
+          template: "universal",
+          skipInstall: true,
+          skipGit: true,
+          yes: true,
+          pieces: ["solana" as never],
+        }),
+      ).rejects.toThrow(/Unknown piece "solana"/u);
+    });
+
+    it("defaults provenance pieces to [] for pre-piece scaffolds", () => {
+      const legacy = mkdtempSync(join(tmpdir(), "mpo-legacy-prov-"));
+      writeFileSync(
+        join(legacy, ".mpo.json"),
+        JSON.stringify({
+          template: "universal",
+          cliVersion: "6.4.0",
+          name: "legacy",
+          mpoVersion: "^6.4.0",
+        }),
+      );
+      expect(readProvenance(legacy)?.pieces).toEqual([]);
+      rmSync(legacy, { recursive: true, force: true });
+    });
+  });
+
+  describe("mergeJsonValues", () => {
+    it("unions arrays preserving base order", () => {
+      expect(mergeJsonValues(["a", "b"], ["b", "c"])).toEqual(["a", "b", "c"]);
+    });
+
+    it("merges nested objects with fragment scalars winning", () => {
+      expect(
+        mergeJsonValues(
+          { scripts: { dev: "vite" }, private: true },
+          { scripts: { build: "vite build", dev: "vite --host" } },
+        ),
+      ).toEqual({ scripts: { dev: "vite --host", build: "vite build" }, private: true });
+    });
+
+    it("replaces on type mismatch", () => {
+      expect(mergeJsonValues({ a: 1 }, ["x"])).toEqual(["x"]);
+    });
+  });
 });