@mangtre/cli 0.1.0

package/src/commands/build.ts

@@ -0,0 +1,62 @@
+/**
+ * `mang build` — run the app's Vite library build (in cwd) → `dist/app.js`, then auto-preflight it
+ * with the same gate the server uses. Resolves the app's locally-installed `vite` bin directly
+ * (package-manager agnostic — no npx/pnpm guessing).
+ */
+
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { checkBundle } from "../lib/check";
+import { reportCheck } from "./check";
+
+const OUTPUT = "dist/app.js";
+
+/** Locate the app's installed `vite` bin, or null if Vite isn't a dependency yet. */
+function resolveViteBin(cwd: string): string | null {
+  try {
+    const require = createRequire(resolve(cwd, "package.json"));
+    const pkgPath = require.resolve("vite/package.json");
+    return join(dirname(pkgPath), "bin", "vite.js");
+  } catch {
+    return null;
+  }
+}
+
+export async function runBuild(_argv: string[]): Promise<void> {
+  const cwd = process.cwd();
+  if (!existsSync(resolve(cwd, "vite.config.ts"))) {
+    console.error("Không thấy vite.config.ts trong thư mục này. Chạy trong thư mục mini-app.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const viteBin = resolveViteBin(cwd);
+  if (!viteBin) {
+    console.error("Không tìm thấy vite. Chạy `pnpm install` trong thư mục app trước.");
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log("🔨 Đang build (vite)…");
+  const res = spawnSync(process.execPath, [viteBin, "build"], { stdio: "inherit", cwd });
+  if (res.status !== 0) {
+    console.error("❌ Vite build thất bại.");
+    process.exitCode = res.status ?? 1;
+    return;
+  }
+
+  const out = resolve(cwd, OUTPUT);
+  if (!existsSync(out)) {
+    console.error(`Build xong nhưng không thấy ${OUTPUT}. Kiểm tra cấu hình mangLibConfig.`);
+    process.exitCode = 1;
+    return;
+  }
+  const source = await readFile(out, "utf8");
+  console.log("\n🔎 Preflight (chuẩn Măng):");
+  const result = checkBundle({ source });
+  reportCheck(result);
+  if (!result.passed) process.exitCode = 1;
+}

package/src/commands/check.ts

@@ -0,0 +1,45 @@
+/**
+ * `mang check [bundlePath] [--app <id>]` — offline preflight of a built bundle against the shared
+ * "chuẩn Măng" gate. Exits non-zero on any `fail` finding. Default path: `dist/app.js`.
+ */
+
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { type CheckResult, checkBundle } from "../lib/check";
+import { getFlag } from "./args";
+
+const DEFAULT_BUNDLE = "dist/app.js";
+
+/** Print findings + a verdict; returns the result. */
+export function reportCheck(result: CheckResult): void {
+  if (!result.manifestFound) {
+    console.error(
+      "⚠️  Không tìm thấy manifest (dòng `// mang-manifest:` ở đầu bundle). Chạy `mang build` trước.",
+    );
+  }
+  const fails = result.findings.filter((f) => f.severity === "fail");
+  const warns = result.findings.filter((f) => f.severity === "warn");
+  for (const f of fails) console.error(`  ✖ [${f.check}] ${f.message}`);
+  for (const f of warns) console.warn(`  ⚠ [${f.check}] ${f.message}`);
+  const kb = (result.bytes / 1024).toFixed(0);
+  if (result.passed) {
+    console.log(`✅ Đạt "chuẩn Măng" (${kb} KB · ${warns.length} cảnh báo). Sẵn sàng đăng.`);
+  } else {
+    console.error(`❌ Chưa đạt (${fails.length} lỗi · ${warns.length} cảnh báo · ${kb} KB).`);
+  }
+}
+
+export async function runCheck(argv: string[]): Promise<void> {
+  const path = argv.find((a) => !a.startsWith("-")) ?? DEFAULT_BUNDLE;
+  const abs = resolve(process.cwd(), path);
+  if (!existsSync(abs)) {
+    console.error(`Không thấy bundle: ${path}. Chạy \`mang build\` trước, hoặc truyền đường dẫn.`);
+    process.exitCode = 1;
+    return;
+  }
+  const source = await readFile(abs, "utf8");
+  const result = checkBundle({ source, appId: getFlag(argv, "app") });
+  reportCheck(result);
+  if (!result.passed) process.exitCode = 1;
+}

package/src/commands/login.ts

@@ -0,0 +1,96 @@
+/**
+ * `mang login` — device-authorization flow. The CLI gets a short code, the user approves it in a
+ * browser where they're signed in, and the CLI is handed an opaque Bearer token (stored 0600).
+ */
+
+import { spawn } from "node:child_process";
+import { ApiError, apiFetch } from "../lib/api";
+import { saveAuth } from "../lib/auth-store";
+import { resolveApiBase } from "../lib/config";
+
+interface DeviceStart {
+  deviceCode: string;
+  userCode: string;
+  verificationUriComplete: string;
+  interval: number;
+  expiresIn: number;
+}
+interface DevicePoll {
+  status: "pending" | "approved" | "denied" | "expired";
+  token?: string;
+  handle?: string;
+}
+
+const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
+
+/** Best-effort: open an http(s) URL in the default browser (never throws). Guards the scheme so a
+ *  malicious `--api` server can't return a URL with shell metacharacters (Windows `start`). */
+function openBrowser(url: string): void {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return;
+    if (process.platform === "darwin") {
+      spawn("open", [parsed.href], { stdio: "ignore", detached: true }).unref();
+    } else if (process.platform === "win32") {
+      // `start "" <url>` with shell:false — the empty title arg prevents URL-as-command injection.
+      spawn("cmd", ["/c", "start", "", parsed.href], { stdio: "ignore", detached: true }).unref();
+    } else {
+      spawn("xdg-open", [parsed.href], { stdio: "ignore", detached: true }).unref();
+    }
+  } catch {
+    // ignore — the URL is printed for manual opening
+  }
+}
+
+export async function runLogin(argv: string[]): Promise<void> {
+  const base = resolveApiBase(argv);
+  let start: DeviceStart;
+  try {
+    start = await apiFetch<DeviceStart>("/v1/auth/device/start", { base, method: "POST" });
+  } catch (err) {
+    const is404 = err instanceof ApiError && err.status === 404;
+    console.error(`Không bắt đầu được đăng nhập: ${(err as Error).message}`);
+    if (is404) {
+      console.error(
+        `   API ${base} chưa hỗ trợ đăng nhập thiết bị (có thể chưa deploy Phase 2).\n   Thử: mang login --api https://api-dev.mang.rumitx.com  (hoặc export MANG_API=…)`,
+      );
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log("\n🔑 Đăng nhập Mọc");
+  console.log(`   Mã của bạn: \x1b[1m${start.userCode}\x1b[0m`);
+  console.log(`   Mở: ${start.verificationUriComplete}\n`);
+  openBrowser(start.verificationUriComplete);
+
+  const deadline = Date.now() + start.expiresIn * 1000;
+  const intervalMs = Math.max(2, start.interval) * 1000;
+  process.stdout.write("   Đang chờ duyệt");
+  while (Date.now() < deadline) {
+    await sleep(intervalMs);
+    process.stdout.write(".");
+    let poll: DevicePoll;
+    try {
+      poll = await apiFetch<DevicePoll>("/v1/auth/device/poll", {
+        base,
+        method: "POST",
+        body: { deviceCode: start.deviceCode },
+      });
+    } catch {
+      continue; // transient — keep polling until the deadline
+    }
+    if (poll.status === "approved" && poll.token) {
+      saveAuth({ token: poll.token, api: base, handle: poll.handle });
+      console.log(`\n✅ Đã đăng nhập${poll.handle ? ` (@${poll.handle})` : ""}.`);
+      return;
+    }
+    if (poll.status === "denied") {
+      console.error("\n❌ Yêu cầu bị từ chối.");
+      process.exitCode = 1;
+      return;
+    }
+  }
+  console.error("\n❌ Hết hạn. Chạy lại `mang login`.");
+  process.exitCode = 1;
+}

package/src/commands/new.ts

@@ -0,0 +1,41 @@
+/**
+ * `mang new <slug> [--dir <path>] [--name <name>] [--icon <emoji>]` — scaffold a standard-compliant
+ * mini-app. Default target dir is `./<slug>`.
+ */
+
+import { resolve } from "node:path";
+import { APP_SLUG } from "@mangtre/standard";
+import { scaffoldApp } from "../lib/scaffold";
+import { getFlag, titleFromSlug } from "./args";
+
+export async function runNew(argv: string[]): Promise<void> {
+  const slug = argv.find((a) => !a.startsWith("-"));
+  if (!slug) {
+    console.error("Thiếu slug. Dùng: mang new <slug>");
+    process.exitCode = 1;
+    return;
+  }
+  if (!APP_SLUG.test(slug)) {
+    console.error(`Slug không hợp lệ: "${slug}" — phải là chữ thường, 3–40 ký tự (a-z, 0-9, -).`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const name = getFlag(argv, "name") ?? titleFromSlug(slug);
+  const icon = getFlag(argv, "icon") ?? "🌱";
+  const dir = getFlag(argv, "dir") ?? slug;
+  const targetDir = resolve(process.cwd(), dir);
+
+  try {
+    const written = await scaffoldApp({ slug, name, icon, targetDir });
+    console.log(`✅ Tạo mini-app "${name}" (${slug}) tại ${dir}`);
+    console.log(`   ${written.length} tệp.`);
+    console.log("\nTiếp theo:");
+    console.log(`   cd ${dir} && pnpm install`);
+    console.log("   mang build      # build → dist/app.js + tự check");
+    console.log("   mang check      # preflight offline (giống cổng duyệt của server)");
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  }
+}

package/src/commands/publish.ts

@@ -0,0 +1,118 @@
+/**
+ * `mang publish [bundle]` — preflight a built bundle, ensure the app exists, then upload it as a new
+ * version. Requires `mang login`. Default bundle: `dist/app.js`.
+ */
+
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { ApiError, apiFetch } from "../lib/api";
+import { loadAuth } from "../lib/auth-store";
+import { checkBundle } from "../lib/check";
+import { extractManifestComment } from "../lib/manifest-comment";
+import { reportCheck } from "./check";
+
+const DEFAULT_BUNDLE = "dist/app.js";
+
+interface BundleManifest {
+  id: string;
+  name: string;
+  icon: string;
+  version: string;
+  [k: string]: unknown;
+}
+
+function asManifest(v: unknown): BundleManifest | null {
+  if (v && typeof v === "object" && !Array.isArray(v)) {
+    const m = v as Record<string, unknown>;
+    if (
+      typeof m.id === "string" &&
+      typeof m.name === "string" &&
+      typeof m.icon === "string" &&
+      typeof m.version === "string"
+    ) {
+      return m as BundleManifest;
+    }
+  }
+  return null;
+}
+
+export async function runPublish(argv: string[]): Promise<void> {
+  const auth = loadAuth();
+  if (!auth) {
+    console.error("Chưa đăng nhập. Chạy `mang login` trước.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const path = argv.find((a) => !a.startsWith("-")) ?? DEFAULT_BUNDLE;
+  const abs = resolve(process.cwd(), path);
+  if (!existsSync(abs)) {
+    console.error(`Không thấy bundle: ${path}. Chạy \`mang build\` trước.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const source = await readFile(abs, "utf8");
+  const manifest = asManifest(extractManifestComment(source));
+  if (!manifest) {
+    console.error("Bundle thiếu manifest hợp lệ (dòng `// mang-manifest:`). Chạy `mang build`.");
+    process.exitCode = 1;
+    return;
+  }
+
+  // Local preflight first — never upload something that won't pass the server gate.
+  console.log("🔎 Preflight (chuẩn Măng):");
+  const result = checkBundle({ source, manifest });
+  reportCheck(result);
+  if (!result.passed) {
+    console.error("Sửa các lỗi trên rồi `mang publish` lại.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const base = auth.api;
+  // Ensure the app exists (claim the slug on first publish). 409 = already claimed.
+  try {
+    await apiFetch("/v1/apps", {
+      base,
+      token: auth.token,
+      body: { id: manifest.id, nameVi: manifest.name, icon: manifest.icon },
+    });
+    console.log(`📦 Đã tạo app "${manifest.id}".`);
+  } catch (err) {
+    if (!(err instanceof ApiError) || err.status !== 409) {
+      console.error(`Không tạo được app: ${(err as Error).message}`);
+      process.exitCode = 1;
+      return;
+    }
+    // 409 → slug exists. Confirm it's ours before uploading.
+    const mine = await apiFetch<{ apps: { id: string }[] }>("/v1/apps/mine", {
+      base,
+      token: auth.token,
+    }).catch(() => ({ apps: [] }));
+    if (!mine.apps.some((a) => a.id === manifest.id)) {
+      console.error(`Slug "${manifest.id}" đã thuộc về creator khác.`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  // Upload the version (multipart).
+  const form = new FormData();
+  form.set("bundle", new Blob([source], { type: "text/javascript" }), "app.js");
+  form.set("version", manifest.version);
+  form.set("manifest", JSON.stringify(manifest));
+
+  try {
+    const res = await apiFetch<{ versionId: string; status: string }>(
+      `/v1/apps/${manifest.id}/versions`,
+      { base, token: auth.token, body: form },
+    );
+    console.log(`\n🚀 Đã đăng v${manifest.version} (${res.status}). Version: ${res.versionId}`);
+    console.log("   Theo dõi duyệt: `mang status`.");
+  } catch (err) {
+    console.error(`Đăng thất bại: ${(err as Error).message}`);
+    process.exitCode = 1;
+  }
+}

package/src/commands/run.ts

@@ -0,0 +1,143 @@
+/**
+ * `mang run` — build the mini-app and preview it locally in a browser with a MOCK `MangCore` sdk
+ * (localStorage-backed storage + a stock theme + locale), so a creator SEES their app render before
+ * publishing. Offline, no auth. Build-then-serve; edit code and re-run to refresh.
+ */
+
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+
+const FIRST_PORT = 5174;
+
+/** Locate the app's installed `vite` bin (package-manager agnostic). */
+function resolveViteBin(cwd: string): string | null {
+  try {
+    const require = createRequire(resolve(cwd, "package.json"));
+    return join(dirname(require.resolve("vite/package.json")), "bin", "vite.js");
+  } catch {
+    return null;
+  }
+}
+
+/** Open an http(s) URL in the default browser (never throws). */
+function openBrowser(url: string): void {
+  try {
+    const u = new URL(url);
+    if (u.protocol !== "http:" && u.protocol !== "https:") return;
+    if (process.platform === "darwin")
+      spawn("open", [u.href], { stdio: "ignore", detached: true }).unref();
+    else if (process.platform === "win32")
+      spawn("cmd", ["/c", "start", "", u.href], { stdio: "ignore", detached: true }).unref();
+    else spawn("xdg-open", [u.href], { stdio: "ignore", detached: true }).unref();
+  } catch {
+    // ignore — URL is printed for manual opening
+  }
+}
+
+// A stock ThemeTokens for the preview (the real one comes from the shell at runtime).
+const PREVIEW_THEME = JSON.stringify({
+  color: {
+    mangGreen: "#37B693",
+    shoot: "#8FE3B8",
+    bamboo: "#1F7A5C",
+    soil: "#B5793A",
+    sun: "#E8C547",
+    paper: "#F4F1E8",
+    dark: "#14201C",
+  },
+  font: { heading: "Quicksand", body: "Inter" },
+});
+
+/** The harness page: imports the built bundle, hands it a mock sdk, runs prepareDemo + mount. */
+function harnessHtml(): string {
+  return `<!doctype html>
+<html lang="vi"><head><meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width,initial-scale=1"/>
+<title>Mọc preview</title><style>body{margin:0}</style></head>
+<body><div id="root"></div>
+<script type="module">
+import { mount, prepareDemo } from "./app.js";
+const NS = "mang:preview:";
+const storage = {
+  get: async (k) => { const v = localStorage.getItem(NS + k); return v == null ? null : JSON.parse(v); },
+  set: async (k, val) => { localStorage.setItem(NS + k, JSON.stringify(val)); },
+  list: async (p = "") => Object.keys(localStorage).filter((k) => k.startsWith(NS + p)).map((k) => k.slice(NS.length)),
+};
+const sdk = { storage, theme: ${PREVIEW_THEME}, locale: "vi" };
+try { if (prepareDemo) await prepareDemo(sdk); } catch (e) { console.warn("prepareDemo:", e); }
+mount(document.getElementById("root"), sdk);
+</script></body></html>`;
+}
+
+function contentType(file: string): string {
+  if (file.endsWith(".html")) return "text/html; charset=utf-8";
+  if (file.endsWith(".js")) return "text/javascript; charset=utf-8";
+  if (file.endsWith(".css")) return "text/css; charset=utf-8";
+  return "application/octet-stream";
+}
+
+export async function runRun(_argv: string[]): Promise<void> {
+  const cwd = process.cwd();
+  if (!existsSync(resolve(cwd, "vite.config.ts"))) {
+    console.error("Không thấy vite.config.ts. Chạy trong thư mục mini-app.");
+    process.exitCode = 1;
+    return;
+  }
+  const viteBin = resolveViteBin(cwd);
+  if (!viteBin) {
+    console.error("Không tìm thấy vite. Chạy `pnpm install` trong thư mục app trước.");
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log("🔨 Đang build để xem trước…");
+  const res = spawnSync(process.execPath, [viteBin, "build"], { stdio: "inherit", cwd });
+  if (res.status !== 0) {
+    console.error("❌ Build thất bại.");
+    process.exitCode = res.status ?? 1;
+    return;
+  }
+
+  const distDir = resolve(cwd, "dist");
+  if (!existsSync(join(distDir, "app.js"))) {
+    console.error("Build xong nhưng không thấy dist/app.js.");
+    process.exitCode = 1;
+    return;
+  }
+  await writeFile(join(distDir, "index.html"), harnessHtml(), "utf8");
+
+  const server = createServer(async (req, res) => {
+    const path = (req.url ?? "/").split("?")[0] ?? "/";
+    const file = path === "/" ? "index.html" : path.replace(/^\/+/, "");
+    try {
+      const buf = await readFile(join(distDir, file));
+      res.setHeader("Content-Type", contentType(file));
+      res.end(buf);
+    } catch {
+      res.statusCode = 404;
+      res.end("not found");
+    }
+  });
+
+  let port = FIRST_PORT;
+  server.on("error", (err: NodeJS.ErrnoException) => {
+    if (err.code === "EADDRINUSE" && port < FIRST_PORT + 10) {
+      port += 1;
+      server.listen(port);
+    } else {
+      console.error(`Không mở được server: ${err.message}`);
+      process.exitCode = 1;
+    }
+  });
+  server.listen(port, () => {
+    const url = `http://localhost:${port}/`;
+    console.log(`\n🌱 Xem trước: ${url}`);
+    console.log("   sdk = storage(local) + theme + locale giả lập · Ctrl+C để dừng.");
+    console.log("   Sửa code → chạy lại `mang run` để build + xem lại.");
+    openBrowser(url);
+  });
+}

package/src/commands/status.ts

@@ -0,0 +1,70 @@
+/**
+ * `mang status` — list my apps and each one's latest version review state (live / pending_review /
+ * rejected …) with finding counts + the rejection reason. Requires `mang login`.
+ */
+
+import { apiFetch } from "../lib/api";
+import { loadAuth } from "../lib/auth-store";
+
+interface VersionInfo {
+  version: string;
+  status: string;
+  findings?: { severity: "fail" | "warn" }[];
+  reason?: string | null;
+}
+interface AppInfo {
+  id: string;
+  nameVi: string;
+  icon: string;
+  status: string;
+  versions: VersionInfo[];
+}
+
+const STATUS_ICON: Record<string, string> = {
+  live: "🟢",
+  approved: "🟢",
+  pending_review: "🟡",
+  validating: "🟡",
+  in_review: "🟡",
+  rejected: "🔴",
+  draft: "⚪",
+  delisted: "⚫",
+};
+
+export async function runStatus(_argv: string[]): Promise<void> {
+  const auth = loadAuth();
+  if (!auth) {
+    console.error("Chưa đăng nhập. Chạy `mang login` trước.");
+    process.exitCode = 1;
+    return;
+  }
+
+  let data: { apps: AppInfo[] };
+  try {
+    data = await apiFetch<{ apps: AppInfo[] }>("/v1/apps/mine", {
+      base: auth.api,
+      token: auth.token,
+    });
+  } catch (err) {
+    console.error(`Không lấy được trạng thái: ${(err as Error).message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (data.apps.length === 0) {
+    console.log("Chưa có app nào. Tạo bằng `mang new`, rồi `mang publish`.");
+    return;
+  }
+
+  for (const app of data.apps) {
+    const latest = app.versions[0];
+    const icon = STATUS_ICON[app.status] ?? "•";
+    console.log(`\n${icon} ${app.icon} ${app.nameVi} (${app.id}) — ${app.status}`);
+    if (latest) {
+      const fails = latest.findings?.filter((f) => f.severity === "fail").length ?? 0;
+      const warns = latest.findings?.filter((f) => f.severity === "warn").length ?? 0;
+      console.log(`   v${latest.version}: ${latest.status} · ${fails} lỗi · ${warns} cảnh báo`);
+      if (latest.reason) console.log(`   Lý do: ${latest.reason}`);
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * `mang` — the Mọc CLI. The vibe-coder's path from idea → product → production: scaffold a
+ * standard-compliant mini-app, build it to one ESM, and preflight it against the SAME "chuẩn Măng"
+ * gate the server runs. (Auth + publish/status land in a later Mọc phase.)
+ * Canonical: `sot/Mang_Creator_Toolchain_Moc_v0.1.md`.
+ */
+
+import { runBuild } from "./commands/build";
+import { runCheck } from "./commands/check";
+import { runLogin } from "./commands/login";
+import { runNew } from "./commands/new";
+import { runPublish } from "./commands/publish";
+import { runRun } from "./commands/run";
+import { runStatus } from "./commands/status";
+
+const VERSION = "0.1.0";
+
+function printHelp(): void {
+  console.log(`Mọc — bộ công cụ creator của Măng (CLI: mang v${VERSION})
+
+Cách dùng:
+  mang new <slug> [--dir <path>] [--name <tên>] [--icon <emoji>]
+      Tạo một mini-app mới đúng "chuẩn Măng" (React + Vite + @mangtre/ui).
+  mang build
+      Build mini-app trong thư mục hiện tại → dist/app.js, rồi tự preflight.
+  mang run
+      Build + xem trước app ngay trên trình duyệt (sdk giả lập) — không cần đăng.
+  mang check [bundlePath] [--app <id>]
+      Preflight offline một bundle đã build (giống cổng duyệt của server).
+  mang login [--api <url>]
+      Đăng nhập (device flow) — duyệt mã trên trình duyệt, lưu token cục bộ.
+  mang publish [bundlePath]
+      Preflight + đăng bundle lên Măng (tạo app nếu chưa có). Cần đăng nhập.
+  mang status
+      Xem app của bạn + trạng thái duyệt mỗi version. Cần đăng nhập.
+
+  mang help | --version`);
+}
+
+async function main(): Promise<void> {
+  const [cmd, ...rest] = process.argv.slice(2);
+  switch (cmd) {
+    case "new":
+      return runNew(rest);
+    case "check":
+      return runCheck(rest);
+    case "build":
+      return runBuild(rest);
+    case "run":
+      return runRun(rest);
+    case "login":
+      return runLogin(rest);
+    case "publish":
+      return runPublish(rest);
+    case "status":
+      return runStatus(rest);
+    case "-v":
+    case "--version":
+      console.log(VERSION);
+      return;
+    case undefined:
+    case "help":
+    case "-h":
+    case "--help":
+      printHelp();
+      return;
+    default:
+      console.error(`Lệnh không rõ: ${cmd}\n`);
+      printHelp();
+      process.exitCode = 1;
+  }
+}
+
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});