@multiplatform.one/cli 6.0.4 → 6.3.0

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"],
 };
 

package/src/commands/initApp.spec.ts

@@ -0,0 +1,210 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { initApp } from "./initApp";
+
+const readJson = (path: string) => JSON.parse(readFileSync(path, "utf-8"));
+
+/** Collect dependency ranges by scope for leakage assertions. */
+function depRanges(pkg: {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}): Record<string, string> {
+  return { ...pkg.dependencies, ...pkg.devDependencies };
+}
+
+describe("initApp generator", () => {
+  let sandbox: string;
+  let previousCwd: string;
+
+  beforeAll(() => {
+    sandbox = mkdtempSync(join(tmpdir(), "mpo-initapp-spec-"));
+    previousCwd = process.cwd();
+    process.chdir(sandbox);
+  });
+
+  afterAll(() => {
+    process.chdir(previousCwd);
+    rmSync(sandbox, { recursive: true, force: true });
+  });
+
+  describe("universal template", () => {
+    const name = "uni-demo";
+    let root: string;
+
+    beforeAll(async () => {
+      await initApp(name, {
+        template: "universal",
+        skipInstall: true,
+        version: "6.1.0",
+        yes: true,
+      });
+      root = join(sandbox, name);
+    });
+
+    it("writes the workspace tree", () => {
+      for (const file of [
+        "package.json",
+        "pnpm-workspace.yaml",
+        "tsconfig.base.json",
+        "oxlintrc.json",
+        "AGENTS.md",
+        "README.md",
+        ".gitignore",
+        ".npmrc",
+        `apps/${name}/package.json`,
+        `apps/${name}/vite.config.ts`,
+        `apps/${name}/app.config.js`,
+        `apps/${name}/tamagui.css`,
+        `apps/${name}/types.d.ts`,
+        `apps/${name}/config/tamagui.config.ts`,
+        `apps/${name}/routes/_layout.tsx`,
+        `apps/${name}/routes/_layout.web.tsx`,
+        `apps/${name}/routes/index.tsx`,
+        `apps/${name}/routes/about.tsx`,
+        `apps/${name}/src/app.ts`,
+        `apps/${name}/polyfills.ts`,
+        `apps/${name}/polyfills.native.ts`,
+        `features/${name}/package.json`,
+        `features/${name}/vitest.config.mjs`,
+        `features/${name}/src/HomeScreen.tsx`,
+        `features/${name}/src/AboutScreen.tsx`,
+        `features/${name}/src/AppLayout.tsx`,
+        `features/${name}/src/ContactForm.tsx`,
+        `features/${name}/src/ContactForm.spec.tsx`,
+        "packages/config/package.json",
+        "packages/i18n/en/common.json",
+        "packages/i18n/es/common.json",
+        "packages/i18n/resources.ts",
+        "packages/themes/tamagui.config.ts",
+        "packages/themes/fonts.ts",
+        "packages/themes/base.ts",
+        "packages/themes/accent.ts",
+        "types/env.d.ts",
+      ]) {
+        expect(existsSync(join(root, file)), `missing ${file}`).toBe(true);
+      }
+    });
+
+    it("restores dotfile names stripped by npm pack", () => {
+      expect(readFileSync(join(root, ".npmrc"), "utf-8")).toContain("node-linker=hoisted");
+      expect(readFileSync(join(root, ".gitignore"), "utf-8")).toContain("node_modules");
+      expect(existsSync(join(root, "npmrc"))).toBe(false);
+      expect(existsSync(join(root, "gitignore"))).toBe(false);
+    });
+
+    it("pins @multiplatform.one/* to semver and locals to workspace:*", () => {
+      for (const pkgPath of [
+        `apps/${name}/package.json`,
+        `features/${name}/package.json`,
+        "packages/i18n/package.json",
+        "packages/themes/package.json",
+      ]) {
+        const ranges = depRanges(readJson(join(root, pkgPath)));
+        for (const [dep, range] of Object.entries(ranges)) {
+          if (dep.startsWith("@multiplatform.one/")) {
+            expect(range, `${pkgPath} ${dep}`).toBe("^6.1.0");
+          } else if (dep.startsWith("@features/") || dep.startsWith("@package/")) {
+            expect(range, `${pkgPath} ${dep}`).toBe("workspace:*");
+          } else {
+            expect(range, `${pkgPath} ${dep} leaked a workspace range`).not.toMatch(/^workspace:/u);
+          }
+        }
+      }
+    });
+
+    it("renders template vars (no placeholders left)", () => {
+      const appPkg = readJson(join(root, `apps/${name}/package.json`));
+      expect(appPkg.name).toBe(`@app/${name}`);
+      const rootPkg = readJson(join(root, "package.json"));
+      expect(rootPkg.name).toBe(name);
+      const appConfig = readFileSync(join(root, `apps/${name}/app.config.js`), "utf-8");
+      expect(appConfig).toContain('name: "UniDemo"');
+      expect(appConfig).toContain("com.unidemo.app");
+      const viteConfig = readFileSync(join(root, `apps/${name}/vite.config.ts`), "utf-8");
+      expect(viteConfig).toContain('key: "UniDemo"');
+      for (const file of [
+        "package.json",
+        "README.md",
+        `apps/${name}/app.config.js`,
+        `features/${name}/src/HomeScreen.tsx`,
+        "packages/i18n/en/common.json",
+      ]) {
+        expect(readFileSync(join(root, file), "utf-8")).not.toMatch(/__NAME(_PASCAL|_APPID)?__/u);
+      }
+    });
+
+    it("wires universal scripts", () => {
+      const rootPkg = readJson(join(root, "package.json"));
+      for (const script of [
+        "dev",
+        "build",
+        "native",
+        "ios",
+        "android",
+        "test",
+        "lint",
+        "typecheck",
+      ]) {
+        expect(rootPkg.scripts[script], `root script ${script}`).toBeDefined();
+      }
+      const appPkg = readJson(join(root, `apps/${name}/package.json`));
+      expect(appPkg.scripts.dev).toContain("one dev");
+      expect(appPkg.scripts.build).toBe("one build");
+      expect(appPkg.scripts["prebuild:native"]).toBe("one prebuild");
+    });
+  });
+
+  describe("app (web-only) template regression", () => {
+    const name = "web-demo";
+    let root: string;
+
+    beforeAll(async () => {
+      await initApp(name, {
+        template: "app",
+        skipInstall: true,
+        version: "6.1.0",
+        yes: true,
+      });
+      root = join(sandbox, name);
+    });
+
+    it("keeps the web-only tree (no universal extras)", () => {
+      for (const file of [
+        "package.json",
+        ".npmrc",
+        ".gitignore",
+        `apps/${name}/vite.config.ts`,
+        `apps/${name}/src/main.tsx`,
+        `features/${name}/src/HomeScreen.tsx`,
+        "packages/config/package.json",
+      ]) {
+        expect(existsSync(join(root, file)), `missing ${file}`).toBe(true);
+      }
+      expect(existsSync(join(root, "packages/i18n"))).toBe(false);
+      expect(existsSync(join(root, "packages/themes"))).toBe(false);
+      expect(existsSync(join(root, `apps/${name}/routes`))).toBe(false);
+    });
+
+    it("keeps semver deps and web scripts", () => {
+      const appPkg = readJson(join(root, `apps/${name}/package.json`));
+      expect(appPkg.dependencies["@multiplatform.one/components"]).toBe("^6.1.0");
+      expect(appPkg.dependencies[`@features/${name}`]).toBe("workspace:*");
+      expect(appPkg.scripts.dev).toBe("vite");
+    });
+  });
+
+  it("rejects invalid names", async () => {
+    await expect(
+      initApp("Bad Name", { template: "app", skipInstall: true, yes: true }),
+    ).rejects.toThrow(/Invalid project name/u);
+  });
+
+  it("refuses to scaffold into a non-empty directory", async () => {
+    await initApp("occupied", { template: "app", skipInstall: true, yes: true });
+    await expect(
+      initApp("occupied", { template: "app", skipInstall: true, yes: true }),
+    ).rejects.toThrow(/already exists and is not empty/u);
+  });
+});

package/src/commands/initApp.ts

@@ -0,0 +1,228 @@
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import inquirer from "inquirer";
+import spawn from "nano-spawn";
+
+/**
+ * Consumer project templates:
+ *   - "universal": one-based app serving web + iOS + Android from one codebase
+ *     (apps/<name> + features/<name> + packages/{config,i18n,themes})
+ *   - "app": web-only Vite + React shell
+ *     (apps/<name> + features/<name> + packages/config)
+ */
+export type InitAppTemplate = "universal" | "app";
+
+export interface InitAppOptions {
+  /** Skip pnpm install (useful for CI / dry scaffolding). */
+  skipInstall?: boolean;
+  /** Pin @multiplatform.one/* to this semver range. Default: ^<cli version>. */
+  version?: string;
+  /** Project template. When omitted: prompt (interactive) or "universal". */
+  template?: InitAppTemplate;
+  /** Accept defaults instead of prompting (non-interactive / CI). */
+  yes?: boolean;
+}
+
+type TemplateVars = {
+  NAME: string;
+  NAME_PASCAL: string;
+  /** Lowercase alphanumeric form for iOS bundle ids / Android packages. */
+  NAME_APPID: string;
+  MPO_VERSION: string;
+  YEAR: string;
+};
+
+function toPascalCase(name: string): string {
+  return name
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}
+
+function validateName(name: string): string {
+  const trimmed = name.trim();
+  if (!trimmed) {
+    throw new Error("Project name is required");
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(trimmed)) {
+    throw new Error(
+      `Invalid project name "${trimmed}". Use lowercase letters, numbers, and hyphens (e.g. my-app).`,
+    );
+  }
+  return trimmed;
+}
+
+function resolveMpoVersion(explicit?: string): string {
+  if (explicit) {
+    return explicit.startsWith("^") || explicit.startsWith("~") || explicit === "*"
+      ? explicit
+      : `^${explicit}`;
+  }
+  try {
+    const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), "../../package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as { version?: string };
+    if (pkg.version) return `^${pkg.version}`;
+  } catch {
+    // fall through
+  }
+  return "^6.1.0";
+}
+
+function templatesRoot(template: InitAppTemplate): string {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "../../templates", template);
+}
+
+/**
+ * npm always strips .gitignore / .npmrc from published tarballs, so the
+ * template stores them without the leading dot; restore it at scaffold time.
+ */
+const DOTFILE_NAMES: Record<string, string> = {
+  gitignore: ".gitignore",
+  npmrc: ".npmrc",
+};
+
+function render(content: string, vars: TemplateVars): string {
+  return content
+    .replaceAll("__NAME_PASCAL__", vars.NAME_PASCAL)
+    .replaceAll("__NAME_APPID__", vars.NAME_APPID)
+    .replaceAll("__NAME__", vars.NAME)
+    .replaceAll("__MPO_VERSION__", vars.MPO_VERSION)
+    .replaceAll("__YEAR__", vars.YEAR);
+}
+
+/**
+ * Assets copied byte-for-byte — running them through the utf-8 render pass
+ * would corrupt them (fonts ship in the templates for LC-33 stable mount).
+ */
+const BINARY_EXTENSIONS = new Set([".woff2", ".woff", ".ttf", ".otf", ".png", ".jpg", ".ico"]);
+
+function writeTree(srcDir: string, destDir: string, vars: TemplateVars): void {
+  if (!existsSync(srcDir)) {
+    throw new Error(`Project template missing at ${srcDir}`);
+  }
+  mkdirSync(destDir, { recursive: true });
+  for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+    const from = join(srcDir, entry.name);
+    // Template files may use __NAME__ in path segments.
+    const toName = render(DOTFILE_NAMES[entry.name] ?? entry.name, vars);
+    const to = join(destDir, toName);
+    if (entry.isDirectory()) {
+      writeTree(from, to, vars);
+      continue;
+    }
+    if (BINARY_EXTENSIONS.has(extname(entry.name).toLowerCase())) {
+      copyFileSync(from, to);
+      continue;
+    }
+    const raw = readFileSync(from, "utf-8");
+    writeFileSync(to, render(raw, vars));
+  }
+}
+
+async function resolveTemplate(options: InitAppOptions): Promise<InitAppTemplate> {
+  if (options.template) return options.template;
+  if (options.yes || !process.stdout.isTTY) return "universal";
+  const result = await inquirer.prompt([
+    {
+      message: "Which platforms should this project target?",
+      name: "template",
+      type: "list",
+      choices: [
+        { name: "Universal — web + iOS + Android (one)", value: "universal" },
+        { name: "Web only — Vite + React", value: "app" },
+      ],
+      default: "universal",
+    },
+  ]);
+  return result.template as InitAppTemplate;
+}
+
+/**
+ * Scaffold a consumer project (universal by default, web-only with
+ * template: "app") that depends on @multiplatform.one/* at semver ranges
+ * (never workspace:*). This is NOT a monorepo fork.
+ */
+export async function initApp(
+  nameArg: string | undefined,
+  options: InitAppOptions = {},
+): Promise<void> {
+  let projectName = nameArg;
+  if (!projectName) {
+    if (options.yes || !process.stdout.isTTY) {
+      projectName = "my-app";
+    } else {
+      const result = await inquirer.prompt([
+        {
+          message: "What is the app name?",
+          name: "name",
+          type: "input",
+          default: "my-app",
+        },
+      ]);
+      projectName = result.name as string;
+    }
+  }
+
+  const name = validateName(projectName);
+  const template = await resolveTemplate(options);
+  const targetDir = resolve(name);
+
+  if (existsSync(targetDir)) {
+    const entries = readdirSync(targetDir);
+    if (entries.length > 0) {
+      throw new Error(`Directory "${targetDir}" already exists and is not empty`);
+    }
+  }
+
+  const vars: TemplateVars = {
+    NAME: name,
+    NAME_PASCAL: toPascalCase(name),
+    NAME_APPID: name.replaceAll("-", ""),
+    MPO_VERSION: resolveMpoVersion(options.version),
+    YEAR: String(new Date().getFullYear()),
+  };
+
+  const label = template === "universal" ? "universal (web + iOS + Android)" : "web-only";
+  console.log(`\nScaffolding ${label} project at ${targetDir}`);
+  console.log(`  apps/${name}`);
+  console.log(`  features/${name}`);
+  console.log(`  packages/config`);
+  if (template === "universal") {
+    console.log(`  packages/i18n`);
+    console.log(`  packages/themes`);
+  }
+  console.log(`  @multiplatform.one/* → ${vars.MPO_VERSION}\n`);
+
+  writeTree(templatesRoot(template), targetDir, vars);
+
+  if (!options.skipInstall) {
+    console.log("Installing dependencies...");
+    await spawn("pnpm", ["install"], {
+      cwd: targetDir,
+      stdio: "inherit",
+    });
+  } else {
+    console.log("Skipped pnpm install (--skip-install).");
+  }
+
+  console.log(`\n✅ Project created at ${targetDir}`);
+  console.log("\nNext steps:");
+  console.log(`  cd ${name}`);
+  if (options.skipInstall) console.log("  pnpm install");
+  console.log("  pnpm dev        # web dev server");
+  if (template === "universal") {
+    console.log("  pnpm ios        # iOS (requires pnpm dev in another terminal)");
+    console.log("  pnpm android    # Android");
+  }
+  console.log("\nThis project consumes published @multiplatform.one/* packages.");
+  console.log("It is not a fork of the multiplatform.one monorepo.");
+}

package/src/generateVscode.ts

@@ -61,15 +61,36 @@ function launchConfigForApp(app: AppInfo): LaunchConfig[] {
   const configs: LaunchConfig[] = [];
   const wf = "${workspaceFolder}";
 
-  if (name === "vscode" && scripts.dev) {
+  // vscode + webext are delivery targets of the One platform app
+  // (apps/<name>/vscode, apps/<name>/webext) — their dev flows hang off the
+  // app's dev:vscode / dev:webext scripts, staging into dist-vscode /
+  // dist-webext.
+  if (scripts["dev:vscode"]) {
     configs.push({
       name: "vscode dev",
       type: "extensionHost",
       request: "launch",
-      args: ["--disable-extensions", `--extensionDevelopmentPath=${wf}/${relPath}`],
+      args: ["--disable-extensions", `--extensionDevelopmentPath=${wf}/${relPath}/dist-vscode`],
       cwd: `${wf}/${relPath}`,
-      outFiles: [`${wf}/${relPath}/dist/extension/*.js`],
-      preLaunchTask: "npm: dev",
+      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",
+      cwd: `${wf}/${relPath}`,
+      command: "pnpm dev:webext",
     });
   }
 
@@ -159,8 +180,9 @@ interface TasksJson {
 }
 
 async function generateTasksJson(apps: AppInfo[]): Promise<TasksJson | null> {
-  const vscodeApp = apps.find((a) => a.name === "vscode");
-  if (!vscodeApp?.scripts?.dev) {
+  // The vscode target lives inside the platform app (dev:vscode script).
+  const hostApp = apps.find((a) => a.scripts?.["dev:vscode"]);
+  if (!hostApp) {
     return null;
   }
 
@@ -169,7 +191,7 @@ async function generateTasksJson(apps: AppInfo[]): Promise<TasksJson | null> {
     tasks: [
       {
         type: "npm",
-        script: "dev",
+        script: "dev:vscode",
         problemMatcher: {
           owner: "typescript",
           fileLocation: "relative",
@@ -190,7 +212,7 @@ async function generateTasksJson(apps: AppInfo[]): Promise<TasksJson | null> {
         isBackground: true,
         presentation: { reveal: "never" },
         group: { kind: "build", isDefault: true },
-        options: { cwd: "${workspaceFolder}/apps/vscode" },
+        options: { cwd: `\${workspaceFolder}/${hostApp.path}` },
       },
     ],
   };
@@ -211,6 +233,6 @@ export async function generateVscodeConfig(root: string): Promise<void> {
     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)");
+    console.log("Skipped .vscode/tasks.json (no app with a dev:vscode script)");
   }
 }