@chrisluyi/daas-cli 1.3.0 → 1.5.0

package/README.md

@@ -11,8 +11,8 @@ MFE apps have **no build config files** — no `rsbuild.config.ts`, no `vitest.c
 | Package | Version | Description |
 |---|---|---|
 | [`@chrisluyi/daas-cli`](https://www.npmjs.com/package/@chrisluyi/daas-cli) | 1.1.0 | CLI binary — install this as your only devDependency |
-| [`@chrisluyi/rsbuild-config`](https://www.npmjs.com/package/@chrisluyi/rsbuild-config) | 1.1.0 | rsbuild config factory + vitest config — arrives transitively |
-| [`@chrisluyi/template`](https://www.npmjs.com/package/@chrisluyi/template) | 1.0.0 | MFE scaffold templates (services / containers / components structure) |
+| [`@chrisluyi/daas-rsbuild-config`](https://www.npmjs.com/package/@chrisluyi/daas-rsbuild-config) | 1.1.0 | rsbuild config factory + vitest config — arrives transitively |
+| [`@chrisluyi/daas-template`](https://www.npmjs.com/package/@chrisluyi/daas-template) | 1.0.0 | MFE scaffold templates (services / containers / components structure) |
 
 ---
 

package/dist/index.js

@@ -912,6 +912,9 @@ var require_picocolors = __commonJS((exports, module) => {
   module.exports.createColors = createColors2;
 });
 
+// src/index.ts
+import { createLogger as createLogger5, setLogger as setLogger5 } from "@chrisluyi/daas-logger";
+
 // ../../node_modules/.bun/consola@3.4.2/node_modules/consola/dist/core.mjs
 var LogLevels = {
   silent: Number.NEGATIVE_INFINITY,
@@ -2312,9 +2315,18 @@ async function runMain(cmd, opts = {}) {
 }
 
 // src/commands/build.ts
-import { createConfig } from "@chrisluyi/rsbuild-config";
+import { apiTransport, createLogger, setLogger } from "@chrisluyi/daas-logger";
+import { createConfig } from "@chrisluyi/daas-rsbuild-config";
 import { createRsbuild } from "@rsbuild/core";
 
+// src/bridge.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname, relative, resolve as resolve2, sep as sep2 } from "path";
+import {
+  BRIDGE_EXPOSE_KEY,
+  bridgeWrapperModule
+} from "@chrisluyi/daas-rsbuild-config";
+
 // src/daas-config.ts
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
@@ -2332,20 +2344,64 @@ function readDaasConfig(cwd = process.cwd()) {
   }
   const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
   const daas = pkg.daas;
-  if (!daas?.configUrl) {
-    throw new ConfigError("No daas config found in package.json. Run daas init first.");
-  }
   return {
-    configUrl: daas.configUrl,
-    port: daas.port ?? 3000,
-    coverage: daas.coverage,
-    setupFiles: daas.setupFiles
+    configUrl: daas?.configUrl,
+    port: daas?.port ?? 3000,
+    coverage: daas?.coverage,
+    setupFiles: daas?.setupFiles,
+    logUrl: daas?.logUrl,
+    bridge: daas?.bridge ?? false
+  };
+}
+
+// src/bridge.ts
+function prepareBridgeBuild(cwd, manifest) {
+  const exposeValues = Object.values(manifest.exposes);
+  if (exposeValues.length !== 1) {
+    throw new ConfigError(`Bridge MFEs must expose exactly one root component (found ${exposeValues.length}). ` + "A bridge remote is a single full sub-app; expose only its root in mf.manifest.json.");
+  }
+  const wrapperAbsPath = resolve2(cwd, ".daas", "export-app.tsx");
+  const rootAbs = resolve2(cwd, exposeValues[0]);
+  let rootImport = relative(dirname(wrapperAbsPath), rootAbs).split(sep2).join("/");
+  if (!rootImport.startsWith("."))
+    rootImport = `./${rootImport}`;
+  return {
+    manifest: {
+      name: manifest.name,
+      exposes: { [BRIDGE_EXPOSE_KEY]: "./.daas/export-app" }
+    },
+    wrapperAbsPath,
+    wrapperContent: bridgeWrapperModule(rootImport)
+  };
+}
+function writeBridgeWrapper(prep) {
+  mkdirSync(dirname(prep.wrapperAbsPath), { recursive: true });
+  writeFileSync(prep.wrapperAbsPath, prep.wrapperContent);
+}
+
+// src/logger/consolaTransport.ts
+function consolaTransport() {
+  return (entry) => {
+    switch (entry.level) {
+      case "debug":
+        consola.debug(entry.message, entry.context ?? "");
+        break;
+      case "info":
+        consola.info(entry.message);
+        break;
+      case "warn":
+        consola.warn(entry.message);
+        break;
+      case "error":
+        consola.fatal(entry.message);
+        break;
+    }
   };
 }
 
 // src/manifest.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 
 class ManifestError extends Error {
   constructor(message) {
@@ -2354,7 +2410,7 @@ class ManifestError extends Error {
   }
 }
 function readManifest(cwd = process.cwd()) {
-  const manifestPath = resolve2(cwd, "mf.manifest.json");
+  const manifestPath = resolve3(cwd, "mf.manifest.json");
   if (existsSync2(manifestPath)) {
     try {
       const raw = JSON.parse(readFileSync2(manifestPath, "utf8"));
@@ -2368,7 +2424,7 @@ function readManifest(cwd = process.cwd()) {
   return deriveFromPackageJson(cwd);
 }
 function deriveFromPackageJson(cwd) {
-  const pkgPath = resolve2(cwd, "package.json");
+  const pkgPath = resolve3(cwd, "package.json");
   if (!existsSync2(pkgPath)) {
     throw new ManifestError("No package.json found. Are you in an MFE directory?");
   }
@@ -2377,14 +2433,16 @@ function deriveFromPackageJson(cwd) {
   return { name, exposes: { "./App": "./src/App" } };
 }
 function normalizeManifest(raw, cwd) {
-  const base = deriveFromPackageJson(cwd);
+  const hasName = typeof raw.name === "string";
+  const hasExposes = raw.exposes != null;
+  const base = hasName && hasExposes ? null : deriveFromPackageJson(cwd);
   return {
-    name: typeof raw.name === "string" ? raw.name : base.name,
-    exposes: raw.exposes != null ? raw.exposes : base.exposes
+    name: hasName ? raw.name.replace(/-/g, "_") : base.name,
+    exposes: hasExposes ? raw.exposes : base.exposes
   };
 }
 function stripScope(name) {
-  return name.replace(/^@[^/]+\//, "");
+  return name.replace(/^@[^/]+\//, "").replace(/-/g, "_");
 }
 
 // src/output.ts
@@ -2415,15 +2473,15 @@ function getCliVersion() {
 }
 
 // src/remote-config.ts
-import { SUPPORTED_CONFIG_VERSION } from "@chrisluyi/rsbuild-config";
+import { SUPPORTED_CONFIG_VERSION } from "@chrisluyi/daas-rsbuild-config";
 // src/fallback-config.json
 var fallback_config_default = {
   version: "1.0.0",
   minCliVersion: "1.0.0",
   releaseNotesUrl: "https://github.com/your-org/daas-cli/releases",
   shared: {
-    react: "18.3.1",
-    "react-dom": "18.3.1"
+    react: "^19.0.0",
+    "react-dom": "^19.0.0"
   },
   rsbuildConfigVersion: 1
 };
@@ -2500,8 +2558,8 @@ function meetsMinVersion(current, min) {
 }
 
 // src/target.ts
-import { writeFileSync } from "fs";
-import { resolve as resolve3 } from "path";
+import { writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve4 } from "path";
 
 class TargetParseError extends Error {
   constructor(message) {
@@ -2532,7 +2590,7 @@ function generateTsconfigDaas(cwd, target) {
       }
     }
   };
-  writeFileSync(resolve3(cwd, "tsconfig.daas.json"), `${JSON.stringify(content, null, 2)}
+  writeFileSync2(resolve4(cwd, "tsconfig.daas.json"), `${JSON.stringify(content, null, 2)}
 `);
 }
 
@@ -2565,18 +2623,33 @@ var buildCommand = defineCommand({
     const json = args.json;
     try {
       const daasConfig = readDaasConfig();
-      const manifest = readManifest();
+      setLogger(createLogger([consolaTransport(), apiTransport(daasConfig.logUrl)]));
+      let manifest = readManifest();
+      if (daasConfig.bridge) {
+        const prep = prepareBridgeBuild(process.cwd(), manifest);
+        writeBridgeWrapper(prep);
+        manifest = prep.manifest;
+        if (!json)
+          consola.info('Bridge mode: isolated React, exposing ./export-app (register host entry with loader: "bridge")');
+      }
       if (!json)
         consola.start(`Building ${manifest.name}...`);
-      const remoteMeta = await fetchRemoteConfig(daasConfig.configUrl, true);
-      checkCliVersion(remoteMeta);
-      checkConfigVersion(remoteMeta, true);
+      let remoteMeta;
+      if (daasConfig.configUrl) {
+        remoteMeta = await fetchRemoteConfig(daasConfig.configUrl, true);
+        checkCliVersion(remoteMeta);
+        checkConfigVersion(remoteMeta, true);
+      } else {
+        remoteMeta = loadFallback();
+        consola.info("No configUrl \u2014 using built-in fallback config");
+      }
       const target = args.target ? parseTarget(args.target) : undefined;
       if (target)
         generateTsconfigDaas(process.cwd(), target);
       const config = createConfig(manifest, remoteMeta, {
         mode: "production",
-        target
+        target,
+        bridge: daasConfig.bridge
       });
       const rsbuild = await createRsbuild({ rsbuildConfig: config });
       await rsbuild.build();
@@ -2621,7 +2694,8 @@ var buildCommand = defineCommand({
 });
 
 // src/commands/dev.ts
-import { createConfig as createConfig2 } from "@chrisluyi/rsbuild-config";
+import { apiTransport as apiTransport2, createLogger as createLogger2, setLogger as setLogger2 } from "@chrisluyi/daas-logger";
+import { createConfig as createConfig2 } from "@chrisluyi/daas-rsbuild-config";
 import { createRsbuild as createRsbuild2 } from "@rsbuild/core";
 var devCommand = defineCommand({
   meta: { name: "dev", description: "Start MFE dev server" },
@@ -2641,12 +2715,25 @@ var devCommand = defineCommand({
   async run({ args }) {
     try {
       const daasConfig = readDaasConfig();
-      const manifest = readManifest();
-      const remoteMeta = await fetchRemoteConfig(daasConfig.configUrl, false);
-      checkCliVersion(remoteMeta);
-      const versionOk = checkConfigVersion(remoteMeta, false);
-      if (!versionOk) {
-        consola.warn("Config version mismatch \u2014 update daas-cli for full compatibility");
+      setLogger2(createLogger2([consolaTransport(), apiTransport2(daasConfig.logUrl)]));
+      let manifest = readManifest();
+      if (daasConfig.bridge) {
+        const prep = prepareBridgeBuild(process.cwd(), manifest);
+        writeBridgeWrapper(prep);
+        manifest = prep.manifest;
+        consola.info('Bridge mode: isolated React, exposing ./export-app (register host entry with loader: "bridge")');
+      }
+      let remoteMeta;
+      if (daasConfig.configUrl) {
+        remoteMeta = await fetchRemoteConfig(daasConfig.configUrl, false);
+        checkCliVersion(remoteMeta);
+        const versionOk = checkConfigVersion(remoteMeta, false);
+        if (!versionOk) {
+          consola.warn("Config version mismatch \u2014 update daas-cli for full compatibility");
+        }
+      } else {
+        remoteMeta = loadFallback();
+        consola.info("No configUrl \u2014 using built-in fallback config");
       }
       const port = args.port ? Number(args.port) : daasConfig.port;
       const target = args.target ? parseTarget(args.target) : undefined;
@@ -2657,7 +2744,8 @@ var devCommand = defineCommand({
       const config = createConfig2(manifest, remoteMeta, {
         mode: "development",
         port,
-        target
+        target,
+        bridge: daasConfig.bridge
       });
       consola.start(`Starting ${manifest.name} dev server...`);
       const rsbuild = await createRsbuild2({ rsbuildConfig: config });
@@ -2698,22 +2786,86 @@ function handleError(command, e2, json) {
   process.exit(EXIT_CODES.GENERAL_ERROR);
 }
 
-// src/init/monorepo.ts
+// src/commands/host.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { dirname, resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
+import { createHostConfig } from "@chrisluyi/daas-rsbuild-config";
+import { createRsbuild as createRsbuild3 } from "@rsbuild/core";
+function sanitizeName(name) {
+  return name.replace(/^@[^/]+\//, "").replace(/[^a-zA-Z0-9]/g, "_");
+}
+function readHostPackage(cwd = process.cwd()) {
+  const pkgPath = resolve5(cwd, "package.json");
+  if (!existsSync3(pkgPath)) {
+    throw new Error("No package.json found. Are you in a host app directory?");
+  }
+  const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+  const daas = pkg.daas ?? {};
+  return {
+    name: sanitizeName(pkg.name ?? "host"),
+    port: daas.port ?? 3000
+  };
+}
+var hostDevCommand = defineCommand({
+  meta: { name: "dev", description: "Start host shell dev server" },
+  async run() {
+    try {
+      const { name, port } = readHostPackage();
+      const config = createHostConfig(name, { mode: "development", port });
+      consola.start(`Starting ${name} dev server...`);
+      const rsbuild = await createRsbuild3({ rsbuildConfig: config });
+      const server = await rsbuild.createDevServer();
+      await server.listen();
+      consola.success(`Ready on http://localhost:${port}`);
+    } catch (e2) {
+      consola.fatal(e2);
+      process.exit(1);
+    }
+  }
+});
+var hostBuildCommand = defineCommand({
+  meta: { name: "build", description: "Build host shell for production" },
+  async run() {
+    try {
+      const { name } = readHostPackage();
+      const config = createHostConfig(name, { mode: "production" });
+      consola.start(`Building ${name}...`);
+      const rsbuild = await createRsbuild3({ rsbuildConfig: config });
+      await rsbuild.build();
+      consola.success("Build complete");
+    } catch (e2) {
+      consola.fatal(e2);
+      process.exit(1);
+    }
+  }
+});
+var hostCommand = defineCommand({
+  meta: { name: "host", description: "Commands for host shell apps" },
+  subCommands: {
+    dev: hostDevCommand,
+    build: hostBuildCommand
+  }
+});
+
+// src/commands/info.ts
+import { apiTransport as apiTransport3, createLogger as createLogger3, setLogger as setLogger3 } from "@chrisluyi/daas-logger";
+
+// src/init/monorepo.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, resolve as resolve6 } from "path";
 function detectMonorepo(startDir) {
   let dir = startDir;
   for (let i2 = 0;i2 < 10; i2++) {
-    const parent = dirname(dir);
+    const parent = dirname2(dir);
     if (parent === dir)
       break;
     dir = parent;
-    if (existsSync3(resolve4(dir, "bun.lockb")))
+    if (existsSync4(resolve6(dir, "bun.lockb")))
       return true;
-    const pkgPath = resolve4(dir, "package.json");
-    if (existsSync3(pkgPath)) {
+    const pkgPath = resolve6(dir, "package.json");
+    if (existsSync4(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
         if (pkg.workspaces)
           return true;
       } catch {}
@@ -2738,6 +2890,7 @@ var infoCommand = defineCommand({
     let manifest;
     try {
       daasConfig = readDaasConfig();
+      setLogger3(createLogger3([consolaTransport(), apiTransport3(daasConfig.logUrl)]));
       manifest = readManifest();
     } catch (e2) {
       if (json)
@@ -2747,9 +2900,13 @@ var infoCommand = defineCommand({
     }
     const isMonorepo = detectMonorepo(process.cwd());
     let remoteJson;
-    try {
-      remoteJson = await fetchRemoteConfig(daasConfig.configUrl, true);
-    } catch {
+    if (daasConfig.configUrl) {
+      try {
+        remoteJson = await fetchRemoteConfig(daasConfig.configUrl, true);
+      } catch {
+        remoteJson = { ...loadFallback(), offline: true };
+      }
+    } else {
       remoteJson = { ...loadFallback(), offline: true };
     }
     const payload = {
@@ -2769,10 +2926,10 @@ var infoCommand = defineCommand({
 });
 
 // src/commands/init.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { createRequire } from "module";
-import { resolve as resolve6 } from "path";
-import { scaffold } from "@chrisluyi/template";
+import { resolve as resolve8 } from "path";
+import { scaffold } from "@chrisluyi/daas-template";
 
 // ../../node_modules/.bun/@clack+core@0.3.5/node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
@@ -3265,10 +3422,10 @@ var de = () => {
 };
 
 // src/init/copy-template.ts
-import { copyFileSync, existsSync as existsSync4, mkdirSync, readdirSync } from "fs";
-import { dirname as dirname2, join } from "path";
+import { copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import { dirname as dirname3, join } from "path";
 import { fileURLToPath } from "url";
-var __dirname2 = dirname2(fileURLToPath(import.meta.url));
+var __dirname2 = dirname3(fileURLToPath(import.meta.url));
 var TEMPLATES_DIR = join(__dirname2, "../../templates/mfe");
 async function copyTemplate(destDir) {
   const files = readdirSync(TEMPLATES_DIR);
@@ -3279,9 +3436,9 @@ async function copyTemplate(destDir) {
     let dest = join(destDir, destFile);
     if (destFile === "App.tsx" || destFile === "App.test.tsx") {
       dest = join(destDir, "src", destFile);
-      mkdirSync(join(destDir, "src"), { recursive: true });
+      mkdirSync2(join(destDir, "src"), { recursive: true });
     }
-    if (existsSync4(dest)) {
+    if (existsSync5(dest)) {
       const overwrite = await se({
         message: `${destFile} already exists. Overwrite?`
       });
@@ -3297,11 +3454,11 @@ async function copyTemplate(destDir) {
 }
 
 // src/init/package-json.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve7 } from "path";
 function updatePackageJson(cwd, opts) {
-  const pkgPath = resolve5(cwd, "package.json");
-  const pkg = existsSync5(pkgPath) ? JSON.parse(readFileSync4(pkgPath, "utf8")) : {};
+  const pkgPath = resolve7(cwd, "package.json");
+  const pkg = existsSync6(pkgPath) ? JSON.parse(readFileSync5(pkgPath, "utf8")) : {};
   pkg.scripts = {
     ...pkg.scripts ?? {},
     dev: "daas dev",
@@ -3310,9 +3467,10 @@ function updatePackageJson(cwd, opts) {
   };
   pkg.dependencies = {
     ...pkg.dependencies ?? {},
+    "@module-federation/bridge-react": "*",
     "@radix-ui/react-tabs": "^1.1.0",
     ...opts.isFullTemplate ? {
-      "@chrisluyi/template": `^${opts.templateVersion ?? opts.cliVersion ?? "1.0.0"}`,
+      "@chrisluyi/daas-template": `^${opts.templateVersion ?? opts.cliVersion ?? "1.0.0"}`,
       "@tanstack/react-query": "^5.0.0",
       zustand: "^5.0.0",
       immer: "^10.0.0",
@@ -3326,7 +3484,7 @@ function updatePackageJson(cwd, opts) {
     };
   }
   pkg.daas = { configUrl: opts.configUrl, port: opts.port };
-  writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
+  writeFileSync3(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `);
 }
 
@@ -3410,7 +3568,7 @@ var initCommand = defineCommand({
     s2.message("\u2713 Updated package.json");
     if (hasExtraExposes) {
       const manifest = { name: appName, exposes: { "./App": "./src/App" } };
-      writeFileSync3(resolve6(cwd, "mf.manifest.json"), `${JSON.stringify(manifest, null, 2)}
+      writeFileSync4(resolve8(cwd, "mf.manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
       s2.message("\u2713 Created mf.manifest.json (add extra exposes as needed)");
     }
@@ -3421,26 +3579,225 @@ var initCommand = defineCommand({
 function getTemplateVersion() {
   try {
     const req = createRequire(import.meta.url);
-    const pkg = req("@chrisluyi/template/package.json");
+    const pkg = req("@chrisluyi/daas-template/package.json");
     return pkg.version ?? "1.0.0";
   } catch {
     return "1.0.0";
   }
 }
 function getPackageName(cwd) {
-  const pkgPath = resolve6(cwd, "package.json");
-  if (!existsSync6(pkgPath))
+  const pkgPath = resolve8(cwd, "package.json");
+  if (!existsSync7(pkgPath))
     return "mfe-app";
   try {
-    const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
     return (pkg.name ?? "mfe-app").replace(/^@[^/]+\//, "");
   } catch {
     return "mfe-app";
   }
 }
 
+// src/region.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { relative as relative2, resolve as resolve9 } from "path";
+
+class RegionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RegionError";
+  }
+}
+var DEFAULT_ALIASES = {
+  "@region-config": "./src/config/regions/{region}/config",
+  "@regional": "./src/config/regions/{region}/index"
+};
+function readRegionalConfig(cwd = process.cwd()) {
+  const pkgPath = resolve9(cwd, "package.json");
+  if (!existsSync8(pkgPath)) {
+    throw new RegionError("No package.json found. Run from the project root (the daas.regional block lives there).");
+  }
+  const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
+  const r4 = pkg.daas?.regional ?? {};
+  return {
+    ...r4,
+    regionsDir: r4.regionsDir ?? "src/config/regions",
+    tsconfig: r4.tsconfig ?? "tsconfig.daas.json",
+    extends: r4.extends ?? "./tsconfig.json",
+    bunPaths: r4.bunPaths ?? false
+  };
+}
+function discoverRegions(cwd, cfg) {
+  if (cfg.regions && cfg.regions.length > 0)
+    return cfg.regions;
+  const dir = resolve9(cwd, cfg.regionsDir ?? "src/config/regions");
+  if (!existsSync8(dir)) {
+    throw new RegionError(`regionsDir "${cfg.regionsDir}" does not exist \u2014 set daas.regional.regionsDir or daas.regional.regions in package.json`);
+  }
+  const regions = readdirSync2(dir, { withFileTypes: true }).filter((e3) => e3.isDirectory()).map((e3) => e3.name).sort();
+  if (regions.length === 0) {
+    throw new RegionError(`regionsDir "${cfg.regionsDir}" has no region folders`);
+  }
+  return regions;
+}
+function renderRegionTsconfig(cwd, cfg, region) {
+  const regions = discoverRegions(cwd, cfg);
+  if (!regions.includes(region)) {
+    throw new RegionError(`Unknown region "${region}". Known: ${regions.join(", ")}`);
+  }
+  const aliases = cfg.aliases ?? DEFAULT_ALIASES;
+  const paths = Object.fromEntries(Object.entries(aliases).map(([k3, v3]) => [
+    k3,
+    [v3.replaceAll("{region}", region)]
+  ]));
+  const tsconfigDir = resolve9(cwd, cfg.tsconfig, "..");
+  const regionsDirAbs = resolve9(cwd, cfg.regionsDir);
+  const others = regions.filter((r4) => r4 !== region).map((r4) => relative2(tsconfigDir, resolve9(regionsDirAbs, r4)));
+  const exclude = [...others, ...cfg.multiRegionFiles ?? []];
+  const compilerOptions = {
+    ...cfg.bunPaths ? { baseUrl: ".", ignoreDeprecations: "6.0" } : {},
+    paths
+  };
+  const body = JSON.stringify({ extends: cfg.extends, compilerOptions, exclude }, null, 2);
+  return `// GENERATED by \`daas region ${region}\` \u2014 do not edit; regenerate or \`daas region --reset\`.
+${body}
+`;
+}
+function writeRegionTsconfig(cwd, cfg, region, applyTo) {
+  const content = renderRegionTsconfig(cwd, cfg, region);
+  const out = resolve9(cwd, cfg.tsconfig);
+  writeFileSync5(out, content);
+  if (applyTo) {
+    writeFileSync5(resolve9(cwd, applyTo), content);
+    return { generated: out, applied: resolve9(cwd, applyTo) };
+  }
+  return { generated: out };
+}
+function resetTsconfig(cwd, path) {
+  const rel = relative2(cwd, resolve9(cwd, path));
+  const show = spawnSync("git", ["show", `HEAD:${rel}`], {
+    cwd,
+    encoding: "utf8"
+  });
+  if (show.status !== 0) {
+    throw new RegionError(`Cannot restore "${rel}" from git HEAD: ${show.stderr.trim() || "not a tracked file?"}`);
+  }
+  writeFileSync5(resolve9(cwd, path), show.stdout);
+}
+function runRegionCheck(cwd, cfg, runner = (p) => {
+  const r4 = spawnSync("bunx", ["tsc", "--noEmit", "-p", p], {
+    cwd,
+    encoding: "utf8"
+  });
+  return { ok: r4.status === 0, output: `${r4.stdout ?? ""}${r4.stderr ?? ""}` };
+}) {
+  const results = [];
+  for (const region of discoverRegions(cwd, cfg)) {
+    writeRegionTsconfig(cwd, cfg, region);
+    const { ok, output } = runner(resolve9(cwd, cfg.tsconfig));
+    results.push({ region, ok, output });
+  }
+  return results;
+}
+
+// src/commands/region.ts
+var regionCommand = defineCommand({
+  meta: {
+    name: "region",
+    description: "Region-scoped type programs: generate a tsconfig containing ONLY the selected region (mirror of the build-time region alias swap)"
+  },
+  args: {
+    region: {
+      type: "positional",
+      description: "Region to select (see --list)",
+      required: false
+    },
+    list: { type: "boolean", default: false, description: "List regions" },
+    check: {
+      type: "boolean",
+      default: false,
+      description: "Matrix gate: generate + tsc --noEmit for EVERY region; fails if any region's program fails"
+    },
+    apply: {
+      type: "string",
+      description: "Also overwrite this tsconfig with the generated content (editor + Bun follow the selection); undo with --reset"
+    },
+    reset: {
+      type: "string",
+      description: "Restore this tsconfig from git HEAD (undo --apply)"
+    },
+    json: {
+      type: "boolean",
+      default: false,
+      description: "Machine-readable JSON output"
+    }
+  },
+  async run({ args }) {
+    try {
+      const cwd = process.cwd();
+      const cfg = readRegionalConfig(cwd);
+      if (args.reset) {
+        resetTsconfig(cwd, args.reset);
+        if (args.json)
+          writeJsonSuccess("region", { reset: args.reset });
+        else
+          consola.success(`Restored ${args.reset} from git HEAD`);
+        return;
+      }
+      if (args.list) {
+        const regions = discoverRegions(cwd, cfg);
+        if (args.json)
+          writeJsonSuccess("region", { regions });
+        else
+          consola.info(`Regions: ${regions.join(", ")}`);
+        return;
+      }
+      if (args.check) {
+        const results = runRegionCheck(cwd, cfg);
+        for (const r4 of results) {
+          if (r4.ok)
+            consola.success(`region ${r4.region}`);
+          else {
+            consola.error(`region ${r4.region}`);
+            if (!args.json && r4.output.trim())
+              consola.log(r4.output.trim());
+          }
+        }
+        const failed = results.filter((r4) => !r4.ok);
+        if (args.json)
+          writeJsonSuccess("region", {
+            results: results.map(({ region, ok }) => ({ region, ok }))
+          });
+        if (failed.length > 0)
+          process.exit(EXIT_CODES.GENERAL_ERROR);
+        return;
+      }
+      if (!args.region) {
+        throw new RegionError("Pass a region (see --list), or use --check / --reset");
+      }
+      const { generated, applied } = writeRegionTsconfig(cwd, cfg, args.region, args.apply);
+      if (args.json)
+        writeJsonSuccess("region", { region: args.region, generated, applied });
+      else {
+        consola.success(`Region-scoped tsconfig for "${args.region}" \u2192 ${generated}`);
+        if (applied)
+          consola.info(`Applied to ${applied} (undo: daas region --reset ${args.apply})`);
+      }
+    } catch (err) {
+      if (err instanceof RegionError) {
+        if (args.json)
+          writeJsonError("region", EXIT_CODES.GENERAL_ERROR, err.message, "Check the daas.regional block in package.json (regionsDir/regions/aliases) and run with --list");
+        consola.error(err.message);
+        process.exit(EXIT_CODES.GENERAL_ERROR);
+      }
+      throw err;
+    }
+  }
+});
+
 // src/commands/test.ts
-import { createVitestConfig } from "@chrisluyi/rsbuild-config/vitest";
+import { apiTransport as apiTransport4, createLogger as createLogger4, setLogger as setLogger4 } from "@chrisluyi/daas-logger";
+import { createVitestConfig } from "@chrisluyi/daas-rsbuild-config/vitest";
 import { startVitest } from "vitest/node";
 var testCommand = defineCommand({
   meta: { name: "test", description: "Run MFE tests" },
@@ -3456,6 +3813,7 @@ var testCommand = defineCommand({
     try {
       const manifest = readManifest();
       const daasConfig = readDaasConfig();
+      setLogger4(createLogger4([consolaTransport(), apiTransport4(daasConfig.logUrl)]));
       const config = createVitestConfig(manifest, {
         coverage: daasConfig.coverage,
         setupFiles: daasConfig.setupFiles
@@ -3479,6 +3837,7 @@ var testCommand = defineCommand({
 });
 
 // src/index.ts
+setLogger5(createLogger5([consolaTransport()]));
 var main = defineCommand({
   meta: {
     name: "daas",
@@ -3490,7 +3849,9 @@ var main = defineCommand({
     dev: devCommand,
     build: buildCommand,
     test: testCommand,
-    info: infoCommand
+    info: infoCommand,
+    host: hostCommand,
+    region: regionCommand
   }
 });
 runMain(main);

package/dist/test.js

@@ -1,3 +1,3 @@
 // @bun
 // src/test.ts
-export * from "@chrisluyi/rsbuild-config/test";
+export * from "@chrisluyi/daas-rsbuild-config/test";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrisluyi/daas-cli",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "type": "module",
   "bin": {
     "daas": "./dist/index.js"
@@ -16,27 +16,25 @@
     "skill.md"
   ],
   "scripts": {
-    "build": "bun build src/index.ts --outfile dist/index.js.tmp --target bun --external @rspack/core --external @rspack/lite-tapable --external @rsbuild/core --external @rsbuild/plugin-react --external @module-federation/rsbuild-plugin --external vitest --external @vitest/browser --external @vitest/ui --external tapable --external react-router-dom --external lightningcss --external @chrisluyi/template --external @chrisluyi/rsbuild-config && printf '%s\\n' '#!/usr/bin/env bun' | cat - dist/index.js.tmp > dist/index.js && rm dist/index.js.tmp && chmod +x dist/index.js && bun build src/test.ts --outfile dist/test.js --target bun --external vitest --external @testing-library/react --external @testing-library/user-event --external @chrisluyi/rsbuild-config",
+    "build": "bun build src/index.ts --outfile dist/index.js.tmp --target bun --external @rspack/core --external @rspack/lite-tapable --external @rsbuild/core --external @rsbuild/plugin-react --external @module-federation/rsbuild-plugin --external vitest --external @vitest/browser --external @vitest/ui --external tapable --external react-router-dom --external lightningcss --external @chrisluyi/daas-template --external @chrisluyi/daas-logger --external @chrisluyi/daas-rsbuild-config && printf '%s\\n' '#!/usr/bin/env bun' | cat - dist/index.js.tmp > dist/index.js && rm dist/index.js.tmp && chmod +x dist/index.js && bun build src/test.ts --outfile dist/test.js --target bun --external vitest --external @testing-library/react --external @testing-library/user-event --external @chrisluyi/daas-rsbuild-config",
     "test": "bun test --ignore 'templates/**'"
   },
   "dependencies": {
     "@clack/prompts": "^0.7.0",
-    "@chrisluyi/rsbuild-config": "workspace:*",
-    "@chrisluyi/template": "workspace:*",
-    "@rsbuild/core": "^1.0.0",
+    "@chrisluyi/daas-logger": "workspace:*",
+    "@chrisluyi/daas-rsbuild-config": "workspace:*",
+    "@chrisluyi/daas-template": "workspace:*",
+    "@rsbuild/core": "*",
     "citty": "^0.1.6",
     "consola": "^3.2.3",
-    "vitest": "^2.0.0"
+    "vitest": "*"
   },
-  "devDependencies": {
-    "typescript": "^5.5.0"
+  "engines": {
+    "node": ">=20.19.0"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/Chris-LuYi/daas-cli",
     "directory": "packages/cli"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/skill.md

@@ -96,13 +96,60 @@ src/
   components/App.tsx            ← presentational component
   containers/AppContainer.tsx   ← data/business logic wrapper
   services/index.ts             ← data fetching / API calls
+  flows/                        ← multi-step flows (optional — add when needed)
+    <name>/
+      types.ts                  ← TData interface
+      index.ts                  ← createFlow<TData>(...)
+      steps/                    ← step components (useFlowData / useFlowActions)
   config/
     regions/default.ts          ← region config layer
     platforms/default.ts        ← platform config layer
     products/default.ts         ← product config layer
 ```
 
+## Template Runtime (`@chrisluyi/daas-template/runtime`)
+
+Key utilities available in MFE components:
+
+| Export | Purpose |
+|---|---|
+| `createApiClient` | Region-aware HTTP client (auto-injects X-Region-Id, X-Locale headers) |
+| `createService` | React Query data fetching with Zod validation |
+| `createStore` | Zustand UI state (per-module singleton) |
+| `createForm` | Zod-validated form with regional widget injection |
+| `createFlow` | Router-agnostic multi-step flow engine |
+| `FlowEngine` | Component wrapper — renders current step automatically |
+| `useFlow` | Hook — use when you need a custom layout (progress bar etc.) |
+| `useFlowData` | Step hook — read/write the shared typed data bag |
+| `useFlowActions` | Step hook — `next()`, `back()`, `isFirst`, `isLast` |
+| `useRegional` | Access the full `RegionalRegistry` from any component |
+
+### Flow SDK quick reference
+
+```ts
+// Define
+const myFlow = createFlow<MyData>({
+  id: "MyFlow",
+  steps: [{ id: "step1", component: Step1 }, { id: "step2", component: Step2 }],
+  initialData: {},
+})
+
+// Mount
+const registry = useRegional()
+return <FlowEngine flow={myFlow} registry={registry} />
+
+// Inside a step — no props needed
+const { data, setData } = useFlowData<MyData>()
+const { next, back, isLast } = useFlowActions()
+```
+
+Regional step injection via `RegionalRegistry.flows?`:
+```ts
+createRegistry(defaultRegistry, {
+  flows: { MyFlow: { extraSteps: [{ after: "step1", id: "extra", component: ExtraStep }] } }
+})
+```
+
 ## Roadmap (do not suggest these — not yet implemented)
 
-- v1.5: `daas dev sg-foo-mb-dev` target strings for multi-region builds
 - v2+: `daas lint` — validates project structure against template conventions