@cityholdings/minicube-dev 0.1.1 → 0.1.3

package/README.md

@@ -36,8 +36,17 @@ npm publish
 
 Optional tools, used only by the commands that need them: `adb` (Android preview), Xcode
 command-line tools (`xcrun`, iOS simulator/device preview), `kubectl` (token administration or
-`transport: "kube"`), `@antdigital/cube` in card projects, `cube-pack` (inline card images), and the
-mini program compiler `mini-pkg-builder`.
+`transport: "kube"`), `cube-pack` (inline card images), and the official mPaaS mini program IDE
+(`mPaaS小程序开发者工具`).
+
+Mini programs are compiled with the IDE's own `mini-pkg-builder` (and its `esbuild`), found
+automatically in the default install locations: `/Applications` or `~/Applications` on macOS;
+`%LOCALAPPDATA%\Programs`, `%ProgramFiles%` or the installer's recorded folder on Windows. No
+configuration is needed; `builders.mini` / `MINICUBE_MINI_BUILDER` only override it.
+
+Card projects must install ACT v4 themselves (`npm i -D @antdigital/cube@4`). minicube-dev uses only
+that copy, found from the card directory upwards, and stops if it is missing or older than v4; a
+global `act` (often ACT v2, which the apps cannot load) is never used.
 
 ## Configuration
 
@@ -59,16 +68,15 @@ by `MINICUBE_DEV_CONFIG` / `--config`. Create a skeleton with `minicube-dev conf
   "devices": {
     "android": { "package": "<android application id>", "cubeConnectActivity": "<debug activity accepting cubeActHost/cubeActPort>" },
     "ios": { "bundleId": "<bundle id, physical devices only>" }
-  },
-  "builders": { "mini": "/path/to/mini-pkg-builder" }
+  }
 }
 ```
 
 * `token` or `tokenEnv` (name of an environment variable holding it) per environment.
 * Without `baseUrl` (or with `"transport": "kube"`) requests go through `kubectl port-forward`
   using your local kubeconfig.
-* `builders.mini` is the mini-pkg-builder executable (`mini-pkg-builder-macos-arm64`,
-  `mini-pkg-builder-win-x64.exe`, …) or its runtime `index.js`; `MINICUBE_MINI_BUILDER` overrides it.
+* Optional `"builders": { "mini": "<path>" }` (or `MINICUBE_MINI_BUILDER`) points at another
+  mini-pkg-builder executable or runtime `index.js`, e.g. when the IDE is installed elsewhere.
 
 `minicube-dev doctor` checks the toolchain and every environment's token.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityholdings/minicube-dev",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Command-line workflow for mPaaS mini programs, H5 offline packages and Cube cards: build, debug upload, device preview and release",
   "type": "module",
   "bin": {

package/src/act.js

@@ -2,10 +2,10 @@ import { mkdirSync, openSync } from 'node:fs';
 import { createConnection } from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
-import { cardDir, resolveAct } from './build.js';
+import { cardDir, resolveAct, runAct } from './build.js';
 import { adb, androidSerial } from './device.js';
 import { CliError, log } from './log.js';
-import { delay, run, runSync, spawnDetached } from './proc.js';
+import { delay, runSync, spawnDetached } from './proc.js';
 
 const DEFAULT_PORT = 9001;
 const CONNECT_TIMEOUT_MS = 45_000;
@@ -55,8 +55,7 @@ export function advertisedHost(target) {
  * address is restarted.
  */
 export async function ensureActServer(project, port = DEFAULT_PORT, host = null) {
-  const act = resolveAct(project.root);
-  if (!act) throw new CliError('ACT not found', 'Install it in the card project: npm i -D @antdigital/cube');
+  const act = resolveAct(cardDir(project), project.root);
   if (await isListening(port)) {
     const current = (await serverAddress(port)).host;
     if (!host || current === host) {
@@ -64,13 +63,13 @@ export async function ensureActServer(project, port = DEFAULT_PORT, host = null)
       return act;
     }
     log.detail(`Restarting the ACT server: it advertises ${current}, this device needs ${host}`);
-    await run(act, ['prepare'], { cwd: project.root, capture: true });
+    await runAct(act, ['prepare'], { cwd: project.root, capture: true });
     const freed = Date.now() + 10_000;
     while ((await isListening(port)) && Date.now() < freed) await delay(300);
   }
   mkdirSync(path.join(project.root, '.minicube'), { recursive: true });
   const logFile = path.join(project.root, '.minicube', 'act-server.log');
-  spawnDetached(act, ['server'], { cwd: project.root, logFd: openSync(logFile, 'a'), env: host ? { HOST: host } : undefined });
+  spawnDetached(process.execPath, [act.script, 'server'], { cwd: project.root, logFd: openSync(logFile, 'a'), env: host ? { HOST: host } : undefined });
   const deadline = Date.now() + 20_000;
   while (Date.now() < deadline) {
     await delay(500);
@@ -145,6 +144,6 @@ export async function attachDevice(target, env, devices, port = DEFAULT_PORT) {
 }
 
 export async function deliverCard(project, act) {
-  const result = await run(act, ['preview', cardDir(project)], { cwd: project.root });
+  const result = await runAct(act, ['preview', cardDir(project)], { cwd: project.root });
   if (result.code !== 0) throw new CliError(`act preview failed (exit ${result.code})`);
 }

package/src/build.js

@@ -3,7 +3,7 @@ import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFil
 import os from 'node:os';
 import path from 'node:path';
 import { CliError, log } from './log.js';
-import { run, which } from './proc.js';
+import { run, runSync, which } from './proc.js';
 import { listFiles, zipDirectory } from './zip.js';
 
 export const OUT_DIR = '.minicube';
@@ -39,19 +39,73 @@ function ensureGitIgnored(root) {
 const MINI_REQUIRED_OUTPUTS = ['appConfig.json', 'index.html', 'index.js', 'index.worker.js', 'manifest.json'];
 const MINI_SOURCE_EXCLUDES = new Set([OUT_DIR, '.git', '.idea', '.vscode', '.DS_Store']);
 
+const IDE_NAME = 'mPaaS小程序开发者工具';
+
+/** Where the official mPaaS mini program IDE keeps its compiler (`<app>/builder/`). */
+export function ideBuilderDirs(platform = process.platform, env = process.env, home = os.homedir()) {
+  if (platform === 'darwin') {
+    return ['/Applications', path.join(home, 'Applications')].map((dir) =>
+      path.join(dir, `${IDE_NAME}.app`, 'Contents', 'Resources', 'app', 'builder'));
+  }
+  if (platform === 'win32') {
+    const roots = [
+      env.LOCALAPPDATA && path.win32.join(env.LOCALAPPDATA, 'Programs'),
+      env.ProgramFiles,
+      env['ProgramFiles(x86)'],
+    ].filter(Boolean);
+    return [...roots.map((root) => path.win32.join(root, IDE_NAME)), ...windowsInstallLocations()]
+      .map((dir) => path.win32.join(dir, 'resources', 'app', 'builder'));
+  }
+  return [];
+}
+
+/** Install folders of the IDE recorded by its Windows installer (covers custom locations). */
+function windowsInstallLocations() {
+  const found = [];
+  for (const hive of ['HKCU', 'HKLM']) {
+    try {
+      const { code, stdout } = runSync('reg', ['query', `${hive}\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall`, '/s', '/f', IDE_NAME, '/d']);
+      if (code !== 0) continue;
+      for (const key of stdout.split(/\r?\n/).filter((line) => line.startsWith('HKEY_'))) {
+        const value = runSync('reg', ['query', key, '/v', 'InstallLocation']).stdout.match(/InstallLocation\s+REG_\w+\s+(.+)/);
+        if (value) found.push(value[1].trim().replace(/^"|"$/g, ''));
+      }
+    } catch {
+      // reg.exe unavailable: fall back to the default folders
+    }
+  }
+  return found;
+}
+
+/**
+ * The mini program compiler: MINICUBE_MINI_BUILDER, then builders.mini in the config, then the
+ * copy inside an installed mPaaS mini program IDE. `env` carries the IDE's esbuild, which the
+ * compiler (like the IDE) finds through ESBUILD_BINARY_PATH.
+ */
 export function resolveMiniBuilder(globalConfig) {
   const configured = process.env.MINICUBE_MINI_BUILDER ?? globalConfig.data.builders?.mini;
-  if (!configured || String(configured).includes('<')) {
-    throw new CliError(
-      'No mini program builder configured',
-      'Set builders.mini in the minicube-dev config to the mini-pkg-builder executable (or its runtime index.js), or export MINICUBE_MINI_BUILDER.',
-    );
+  if (configured && !String(configured).includes('<')) {
+    const resolved = which(String(configured)) ?? path.resolve(String(configured));
+    if (!existsSync(resolved)) throw new CliError(`Mini program builder not found: ${resolved}`);
+    return builderAt(resolved);
   }
-  const resolved = which(String(configured)) ?? path.resolve(String(configured));
-  if (!existsSync(resolved)) throw new CliError(`Mini program builder not found: ${resolved}`);
-  return resolved.endsWith('.js') || resolved.endsWith('.mjs')
-    ? { command: process.execPath, prefix: [resolved] }
-    : { command: resolved, prefix: [] };
+  const exe = process.platform === 'win32' ? '.exe' : '';
+  for (const dir of ideBuilderDirs()) {
+    const file = path.join(dir, `mini-pkg-builder${exe}`);
+    if (existsSync(file)) return builderAt(file);
+  }
+  throw new CliError(
+    'No mini program builder found',
+    `Install the mPaaS mini program IDE (${IDE_NAME}), or set builders.mini in the minicube-dev config / MINICUBE_MINI_BUILDER to a mini-pkg-builder executable.`,
+  );
+}
+
+function builderAt(file) {
+  const esbuild = path.join(path.dirname(file), process.platform === 'win32' ? 'esbuild.exe' : 'esbuild');
+  const env = existsSync(esbuild) && !process.env.ESBUILD_BINARY_PATH ? { ESBUILD_BINARY_PATH: esbuild } : {};
+  return file.endsWith('.js') || file.endsWith('.mjs')
+    ? { command: process.execPath, prefix: [file], path: file, env }
+    : { command: file, prefix: [], path: file, env };
 }
 
 function readMiniProjectConfig(sourceDir) {
@@ -87,8 +141,9 @@ async function buildMini(project, globalConfig, outRoot) {
     '--prod', '--no-minify',
   ];
   log.step(`Compiling mini program ${id}`);
+  log.detail(`Compiler ${builder.path}`);
   const logFile = path.join(outRoot, 'mini-build.log');
-  const result = await run(builder.command, args, { cwd: input, capture: true, env: { FORCE_COLOR: '0', NO_COLOR: '1' } });
+  const result = await run(builder.command, args, { cwd: input, capture: true, env: { ...builder.env, FORCE_COLOR: '0', NO_COLOR: '1' } });
   writeFileSync(logFile, `${result.stdout}\n${result.stderr}`);
   rmSync(work, { recursive: true, force: true });
   if (result.code !== 0) {
@@ -176,10 +231,39 @@ async function buildH5(project, outRoot) {
 // ---------------------------------------------------------------------------------------------
 // Cards: cube-pack (inlines local images) when installed, otherwise the project's own `act build`.
 
-export function resolveAct(projectRoot) {
-  const local = which('act', [path.join(projectRoot, 'node_modules', '.bin')]);
-  if (local && local.startsWith(projectRoot)) return local;
-  return local ?? null;
+export const ACT_MIN_MAJOR = 4;
+const ACT_INSTALL_HINT = 'Install ACT v4 in the card project: npm i -D @antdigital/cube@4';
+
+/**
+ * The card project's own ACT v4 CLI script (`@antdigital/cube`), looked up like Node resolves
+ * packages: from each start directory up through its parents. A global `act` is never used — it is
+ * often ACT v2, whose builds and server the apps' v4 Cube host cannot load.
+ */
+export function resolveAct(...startDirs) {
+  for (const start of startDirs) {
+    for (let dir = path.resolve(start); ; dir = path.dirname(dir)) {
+      const pkgDir = path.join(dir, 'node_modules', '@antdigital', 'cube');
+      const pkgFile = path.join(pkgDir, 'package.json');
+      if (existsSync(pkgFile)) {
+        const pkg = JSON.parse(readFileSync(pkgFile, 'utf8'));
+        const major = Number.parseInt(String(pkg.version), 10);
+        if (!(major >= ACT_MIN_MAJOR)) {
+          throw new CliError(`${pkgDir} is ACT ${pkg.version}; ACT v${ACT_MIN_MAJOR} or newer is required`, ACT_INSTALL_HINT);
+        }
+        const bin = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.act;
+        const script = bin && path.join(pkgDir, bin);
+        if (!script || !existsSync(script)) throw new CliError(`${pkgDir} has no act CLI`, ACT_INSTALL_HINT);
+        return { script, version: pkg.version };
+      }
+      if (path.dirname(dir) === dir) break;
+    }
+  }
+  throw new CliError(`ACT v${ACT_MIN_MAJOR} (@antdigital/cube) is not installed in the card project`, ACT_INSTALL_HINT);
+}
+
+/** Run the project's ACT CLI with the current Node (also on Windows, where cli.js is not executable). */
+export function runAct(act, args, options) {
+  return run(process.execPath, [act.script, ...args], options);
 }
 
 export function cardDir(project) {
@@ -189,16 +273,13 @@ export function cardDir(project) {
 async function buildCard(project, outRoot) {
   const dir = cardDir(project);
   if (!existsSync(path.join(dir, 'manifest.json'))) throw new CliError(`${dir} is not a card (no manifest.json)`);
+  // Checked even when cube-pack builds: it runs the project's act, so a missing v4 must stop here.
+  const act = resolveAct(dir, project.root);
   const cubePack = project.data.card?.useCubePack === false ? null : which('cube-pack');
-  log.step(`Building card ${project.data.resourceId}`);
-  let result;
-  if (cubePack) {
-    result = await run(cubePack, ['build'], { cwd: project.root });
-  } else {
-    const act = resolveAct(project.root);
-    if (!act) throw new CliError('ACT not found', 'Install it in the card project: npm i -D @antdigital/cube');
-    result = await run(act, ['build', dir], { cwd: project.root });
-  }
+  log.step(`Building card ${project.data.resourceId} (ACT ${act.version})`);
+  const result = cubePack
+    ? await run(cubePack, ['build'], { cwd: project.root })
+    : await runAct(act, ['build', dir], { cwd: project.root });
   if (result.code !== 0) throw new CliError(`Card build failed (exit ${result.code})`);
   const zip = findCardZip(dir);
   const file = path.join(outRoot, `${project.data.resourceId}.zip`);

package/src/cli.js

@@ -385,7 +385,7 @@ const COMMANDS = {
     const config = loadGlobalConfig(ctx.flags);
     add('config', config.exists, config.file);
     try {
-      add('mini builder', true, resolveMiniBuilder(config).prefix[0] ?? resolveMiniBuilder(config).command);
+      add('mini builder', true, resolveMiniBuilder(config).path);
     } catch (e) {
       add('mini builder', false, e.message);
     }

package/src/config.js

@@ -58,9 +58,6 @@ export const CONFIG_TEMPLATE = {
       bundleId: '<ios bundle id>',
     },
   },
-  builders: {
-    mini: '<path to mini-pkg-builder executable or its runtime index.js>',
-  },
 };
 
 /**