pan-stack-cli 0.1.5 → 0.2.1

package/lib/ui/config.js

@@ -0,0 +1,182 @@
+// lib/ui/config.js — cấu hình `pan ui`: API/WEB URL (.pan-env-build.yaml) + credential store
+// (~/.pan/credentials.json). Không phụ thuộc lib khác ngoài fs/path/os (giữ nhẹ, dễ test).
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const CREDENTIALS_DIR = path.join(os.homedir(), ".pan");
+const CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
+
+// Fallback mặc định khi KHÔNG set env / KHÔNG khai trong .pan-env-build.yaml — trỏ về Pan Studio
+// backend dev trên OpenShift, để `pan ui` dùng được ngay không cần config gì thêm. Ưu tiên (cao
+// → thấp): process.env > .pan-env-build.yaml > default này.
+//
+// URL được XOR obfuscate (KHÔNG phải bảo mật thật — key nằm ngay trong file) — chỉ để tránh lộ
+// domain trần khi grep/quét source code tìm URL literal. Cần đổi URL mặc định? Sửa `_DEFAULT_URL`
+// (chuỗi thường) rồi chạy `node -e` bên dưới để sinh lại mảng byte, KHÔNG gõ tay mảng byte.
+//   node -e "const u='https://...';const K=0x2A;console.log(JSON.stringify([...u].map(c=>c.charCodeAt(0)^K)))"
+const _OBFUSCATE_KEY = 0x2a;
+const _DEFAULT_URL_BYTES = [
+  66, 94, 94, 90, 89, 16, 5, 5, 90, 75, 68, 7, 89, 94, 95, 78, 67, 69, 7, 75, 90, 67, 4, 78, 79, 92,
+  4, 73, 70, 95, 89, 94, 79, 88, 26, 24, 4, 76, 67, 89, 7, 73, 70, 69, 95, 78, 4, 82, 90, 70, 75, 94,
+  4, 69, 68, 70, 67, 68, 79,
+];
+function _deobfuscate(bytes, key) {
+  return bytes.map((b) => String.fromCharCode(b ^ key)).join("");
+}
+const DEFAULT_API_URL = _deobfuscate(_DEFAULT_URL_BYTES, _OBFUSCATE_KEY);
+const DEFAULT_WEB_URL = DEFAULT_API_URL;
+
+/**
+ * Đọc "KEY: value" phẳng từ .pan-env-build.yaml (cùng quy ước với
+ * lib/git/git-mr.js loadGitlabToken — KHÔNG phải YAML parser đầy đủ).
+ * @param {string} envFile
+ * @returns {Record<string,string>}
+ */
+function readEnvFile(envFile) {
+  const result = {};
+  if (!fs.existsSync(envFile)) {
+    return result;
+  }
+  const content = fs.readFileSync(envFile, "utf8");
+  for (const rawLine of content.split(/\r?\n/)) {
+    let line = rawLine;
+    const commentIdx = line.indexOf("#");
+    if (commentIdx >= 0) {
+      line = line.slice(0, commentIdx);
+    }
+    line = line.trim();
+    if (!line) {
+      continue;
+    }
+    const idx = line.indexOf(":");
+    if (idx < 0) {
+      continue;
+    }
+    const key = line.slice(0, idx).trim();
+    let val = line.slice(idx + 1).trim();
+    if (
+      (val.startsWith('"') && val.endsWith('"')) ||
+      (val.startsWith("'") && val.endsWith("'"))
+    ) {
+      val = val.slice(1, -1);
+    }
+    if (key && val) {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+/**
+ * Đọc PAN_STUDIO_API_URL / PAN_STUDIO_WEB_URL. Ưu tiên (cao → thấp):
+ *   1. process.env
+ *   2. `<workspaceRoot>/.pan-env-build.yaml`
+ *   3. DEFAULT_API_URL/DEFAULT_WEB_URL (Pan Studio backend dev — dùng được ngay, không cần config)
+ * WEB_URL riêng thiếu ở cả 3 mức trên thì mặc định = API_URL đã resolve.
+ * @param {string} workspaceRoot
+ * @returns {{ apiUrl: string, webUrl: string }}
+ */
+function getApiConfig(workspaceRoot) {
+  const envFile = path.join(workspaceRoot || process.cwd(), ".pan-env-build.yaml");
+  const fromFile = readEnvFile(envFile);
+
+  const apiUrl =
+    process.env.PAN_STUDIO_API_URL || fromFile.PAN_STUDIO_API_URL || DEFAULT_API_URL;
+  // WEB_URL riêng thiếu → mirror theo apiUrl ĐÃ RESOLVE (không nhảy thẳng DEFAULT_WEB_URL) — vd
+  // user chỉ set PAN_STUDIO_API_URL=http://localhost:3001 trong .pan-env-build.yaml thì WEB_URL
+  // phải là localhost:3001 luôn, không phải URL cluster dev mặc định.
+  const webUrl = process.env.PAN_STUDIO_WEB_URL || fromFile.PAN_STUDIO_WEB_URL || apiUrl;
+
+  return { apiUrl: apiUrl.replace(/\/+$/, ""), webUrl: webUrl.replace(/\/+$/, "") };
+}
+
+function readCredentialsStore() {
+  if (!fs.existsSync(CREDENTIALS_FILE)) {
+    return {};
+  }
+  try {
+    const raw = fs.readFileSync(CREDENTIALS_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeCredentialsStore(store) {
+  if (!fs.existsSync(CREDENTIALS_DIR)) {
+    fs.mkdirSync(CREDENTIALS_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(store, null, 2), {
+    mode: 0o600,
+  });
+  try {
+    fs.chmodSync(CREDENTIALS_FILE, 0o600);
+  } catch {
+    // best-effort trên hệ điều hành không hỗ trợ chmod (vd Windows)
+  }
+}
+
+/**
+ * @param {string} apiUrl
+ * @returns {{ token: string, tokenType: string, expiresAt: string, user: object, savedAt: string } | null}
+ */
+function loadCredential(apiUrl) {
+  const store = readCredentialsStore();
+  return store[apiUrl] || null;
+}
+
+/**
+ * @param {string} apiUrl
+ * @param {{ token: string, tokenType?: string, expiresAt: string, user?: object }} cred
+ */
+function saveCredential(apiUrl, cred) {
+  const store = readCredentialsStore();
+  store[apiUrl] = {
+    token: cred.token,
+    tokenType: cred.tokenType || "pmcp",
+    expiresAt: cred.expiresAt,
+    user: cred.user || null,
+    savedAt: new Date().toISOString(),
+  };
+  writeCredentialsStore(store);
+  return store[apiUrl];
+}
+
+/**
+ * @param {string} apiUrl
+ */
+function clearCredential(apiUrl) {
+  const store = readCredentialsStore();
+  if (apiUrl in store) {
+    delete store[apiUrl];
+    writeCredentialsStore(store);
+  }
+}
+
+/**
+ * @param {{ expiresAt?: string } | null | undefined} cred
+ * @returns {boolean}
+ */
+function isExpired(cred) {
+  if (!cred || !cred.expiresAt) {
+    return true;
+  }
+  const expiresAt = Date.parse(cred.expiresAt);
+  if (Number.isNaN(expiresAt)) {
+    return true;
+  }
+  return expiresAt < Date.now();
+}
+
+module.exports = {
+  CREDENTIALS_FILE,
+  DEFAULT_API_URL,
+  DEFAULT_WEB_URL,
+  getApiConfig,
+  loadCredential,
+  saveCredential,
+  clearCredential,
+  isExpired,
+};

package/lib/ui/diff.js

@@ -0,0 +1,128 @@
+// lib/ui/diff.js — so sánh cây file local ↔ backend, dùng chung cho `sync` (§4.5) và
+// GATE của `published-html`/`gen-react-web-code` (§4.6). Không phụ thuộc lib khác ngoài
+// fs/path/crypto core.
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+const IGNORE_DIRS = new Set(["node_modules", ".git", "dist"]);
+
+/**
+ * Quét đệ quy toàn bộ file (không giới hạn cấp — dùng cho 1 dự án panui, không phải
+ * monorepo scan), bỏ node_modules/.git/dist.
+ * @param {string} rootDir
+ * @returns {Array<{ path: string, size: number, full: string }>}
+ */
+function listLocalFiles(rootDir) {
+  const results = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (IGNORE_DIRS.has(entry.name)) continue;
+        walk(path.join(dir, entry.name));
+        continue;
+      }
+      if (entry.isFile()) {
+        const full = path.join(dir, entry.name);
+        const rel = path.relative(rootDir, full).split(path.sep).join("/");
+        let stat;
+        try {
+          stat = fs.statSync(full);
+        } catch {
+          continue;
+        }
+        results.push({ path: rel, size: stat.size, full });
+      }
+    }
+  }
+  walk(rootDir);
+  return results;
+}
+
+function sha256(content) {
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+/**
+ * So khớp local ↔ backend theo path tương đối. Sizes khác → changed ngay (rẻ).
+ * Sizes bằng nhau (hoặc backend không có size) → nếu có `getBackendContent`, tải nội
+ * dung backend và so hash để chắc chắn (chậm hơn nhưng chính xác — honest-TODO: gọi
+ * 1 request/file, có thể chậm với dự án nhiều file bằng size nhau).
+ * @param {string} localDir
+ * @param {Array<{filePath?:string, path?:string, fileType?:string, fileSize?:number, size?:number}>} backendFiles
+ * @param {(relPath:string)=>Promise<string>} [getBackendContent]
+ * @returns {Promise<{ added: string[], changed: string[], removed: string[], unchanged: string[] }>}
+ */
+async function computeDiff(localDir, backendFiles, getBackendContent) {
+  const local = listLocalFiles(localDir);
+  const localByPath = new Map(local.map((f) => [f.path, f]));
+
+  const backendList = (backendFiles || []).filter(
+    (f) => f.fileType !== "directory" && f.fileType !== "dir"
+  );
+  const backendByPath = new Map(
+    backendList.map((f) => [f.filePath || f.path, f])
+  );
+
+  const added = [];
+  const changed = [];
+  const removed = [];
+  const unchanged = [];
+
+  for (const [relPath, lf] of localByPath) {
+    const bf = backendByPath.get(relPath);
+    if (!bf) {
+      added.push(relPath);
+      continue;
+    }
+    const backendSize = bf.fileSize ?? bf.size;
+    if (typeof backendSize === "number" && backendSize !== lf.size) {
+      changed.push(relPath);
+      continue;
+    }
+    if (getBackendContent) {
+      try {
+        const backendContent = await getBackendContent(relPath);
+        const localContent = fs.readFileSync(lf.full, "utf8");
+        if (sha256(localContent) !== sha256(backendContent || "")) {
+          changed.push(relPath);
+          continue;
+        }
+      } catch {
+        // Không tải được nội dung backend để so — best-effort: coi như không đổi.
+      }
+    }
+    unchanged.push(relPath);
+  }
+
+  for (const relPath of backendByPath.keys()) {
+    if (!localByPath.has(relPath)) {
+      removed.push(relPath);
+    }
+  }
+
+  return { added, changed, removed, unchanged };
+}
+
+function isDiffClean(diff) {
+  return (
+    diff.added.length === 0 && diff.changed.length === 0 && diff.removed.length === 0
+  );
+}
+
+function printDiff(diff) {
+  for (const p of diff.added) console.log(`  + ${p}`);
+  for (const p of diff.changed) console.log(`  ~ ${p}`);
+  for (const p of diff.removed) console.log(`  - ${p}`);
+  console.log(
+    `Tổng: +${diff.added.length} thêm, ~${diff.changed.length} đổi, -${diff.removed.length} xóa, =${diff.unchanged.length} không đổi.`
+  );
+}
+
+module.exports = { listLocalFiles, computeDiff, isDiffClean, printDiff };

package/lib/ui/export-gate.js

@@ -0,0 +1,79 @@
+// lib/ui/export-gate.js — GATE dùng chung cho published-html.js & gen-react-web-code.js
+// (§4.6, OD-U2): chạy diff (như sync), nếu local≠backend thì cảnh báo + hỏi sync trước;
+// đồng thời cung cấp poll trạng thái export/build.
+const sync = require("./sync");
+const { isDiffClean, printDiff } = require("./diff");
+
+async function loadInquirer() {
+  const inq = await import("@inquirer/prompts").catch(() => null);
+  if (!inq) {
+    throw new Error("Cần TTY (@inquirer/prompts) cho lệnh này.");
+  }
+  return inq;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function toList(res) {
+  if (Array.isArray(res)) return res;
+  if (res && Array.isArray(res.items)) return res.items;
+  if (res && Array.isArray(res.data)) return res.data;
+  return [];
+}
+
+/**
+ * Chọn dự án + đảm bảo local == backend trước khi build (sync nếu user đồng ý).
+ * @returns {Promise<{ api, project, backend, projectDir }>}
+ */
+async function ensureSynced() {
+  const resolved = await sync.resolveProject();
+  let state = await sync.diffProject(resolved);
+
+  if (!isDiffClean(state.diff)) {
+    console.log("Local khác backend — cần đồng bộ trước khi build/publish:");
+    printDiff(state.diff);
+    const inq = await loadInquirer();
+    const doSync = await inq.confirm({
+      message: "Đồng bộ (sync) ngay bây giờ?",
+      default: true,
+    });
+    if (!doSync) {
+      throw new Error("Đã dừng — chạy `pan ui sync` trước khi publish/build.");
+    }
+    await sync.pushDiff(state);
+    state = await sync.diffProject(resolved);
+    if (!isDiffClean(state.diff)) {
+      throw new Error("Vẫn còn khác biệt sau khi sync — kiểm tra lại thủ công.");
+    }
+  }
+  return state;
+}
+
+/**
+ * Poll GET /projects/:id/export/versions tới khi phiên bản mới nhất done/failed.
+ * @param {*} api
+ * @param {string} projectId
+ * @param {{ intervalMs?: number, timeoutMs?: number }} [opts]
+ */
+async function pollExportDone(api, projectId, opts = {}) {
+  const { intervalMs = 3000, timeoutMs = 5 * 60 * 1000 } = opts;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const versionsRes = await api.pollExport(projectId);
+    const list = toList(versionsRes);
+    const latest = list[0];
+    if (latest && ["done", "completed", "success"].includes(latest.status)) {
+      return latest;
+    }
+    if (latest && ["failed", "error"].includes(latest.status)) {
+      throw new Error(`Build thất bại: ${latest.error || latest.status}`);
+    }
+    process.stdout.write(".");
+    await sleep(intervalMs);
+  }
+  throw new Error("Hết thời gian chờ build (timeout).");
+}
+
+module.exports = { ensureSynced, pollExportDone };

package/lib/ui/gen-react-mobile-code.js

@@ -0,0 +1,6 @@
+// lib/ui/gen-react-mobile-code.js — STUB. Chưa có kế hoạch (chờ chốt) — chỉ báo "Đang phát triển".
+async function run(_args) {
+  console.log("Đang phát triển");
+}
+
+module.exports = { run };

package/lib/ui/gen-react-web-code.js

@@ -0,0 +1,75 @@
+// lib/ui/gen-react-web-code.js — GATE sync (§4.6, OD-U2) rồi POST /projects/:id/export/react,
+// poll, download .tar.gz (api.js download), giải nén ra thư mục đích (mặc định
+// ./pan-ui-react, lỗi nếu đã tồn tại). Giải nén dùng lệnh `tar` hệ thống qua child_process
+// (không thêm dep nén) — nếu không có `tar`, lưu file .tar.gz + in hướng dẫn (honest-TODO).
+const fs = require("fs");
+const path = require("path");
+const { execFileSync } = require("child_process");
+const { ensureSynced, pollExportDone } = require("./export-gate");
+
+async function loadInquirer() {
+  const inq = await import("@inquirer/prompts").catch(() => null);
+  if (!inq) {
+    throw new Error("Cần TTY (@inquirer/prompts) cho lệnh này.");
+  }
+  return inq;
+}
+
+function hasTarBinary() {
+  try {
+    execFileSync("tar", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function run(_args) {
+  const { api, project, backend } = await ensureSynced();
+
+  console.log(`Đang build mã React web cho '${project.name || project.id}'...`);
+  await api.exportReact(backend.id);
+  console.log("Đang chờ build hoàn tất...");
+  const version = await pollExportDone(api, backend.id);
+
+  const inq = await loadInquirer();
+  const targetInput = await inq.input({
+    message: "Thư mục đích để giải nén mã React (vd: pan-ui-react, ./out/react, /abs/path):",
+    default: "pan-ui-react",
+  });
+  const targetDir = path.isAbsolute(targetInput)
+    ? targetInput
+    : path.resolve(process.cwd(), targetInput);
+
+  if (fs.existsSync(targetDir)) {
+    throw new Error(`Thư mục đã tồn tại: ${targetDir} — xóa thủ công rồi thử lại.`);
+  }
+
+  const downloadUrl =
+    version.downloadUrl ||
+    (version.id && `/export/versions/${version.id}/download`);
+  if (!downloadUrl) {
+    throw new Error(
+      "Build xong nhưng không xác định được downloadUrl/version.id — kiểm tra thủ công `GET /projects/:id/export/versions`."
+    );
+  }
+
+  console.log("Đang tải file build...");
+  const buffer = await api.download(downloadUrl);
+  const tarballPath = `${targetDir}.tar.gz`;
+  fs.writeFileSync(tarballPath, buffer);
+
+  if (hasTarBinary()) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    execFileSync("tar", ["-xzf", tarballPath, "-C", targetDir]);
+    fs.unlinkSync(tarballPath);
+    console.log(`Đã giải nén mã React vào: ${targetDir}`);
+  } else {
+    console.log(
+      `[honest-TODO] Không tìm thấy lệnh 'tar' trên hệ thống — đã lưu file nén tại: ${tarballPath}`
+    );
+    console.log(`Giải nén thủ công: tar -xzf ${tarballPath} -C <thư mục đích>`);
+  }
+}
+
+module.exports = { run };

package/lib/ui/index.js

@@ -0,0 +1,89 @@
+// lib/ui/index.js — router + menu cho `pan ui` (§4.1). Subcommand thật (Wave 2) sống trong
+// lib/ui/<name>.js; ở Phase 2 mọi file đó CHỈ là stub.
+const { menuSelect } = require("../menu-prompt");
+const { t } = require("../i18n");
+
+const SUBCOMMANDS = [
+  { name: "init", label: "init — tạo dự án panui mẫu (chọn loại + bảng màu)" },
+  { name: "login", label: "login — đăng nhập Pan Studio (mở trình duyệt, device-flow)" },
+  { name: "logout", label: "logout — đăng xuất, xóa key local" },
+  { name: "clone", label: "clone — tải dự án panui về local" },
+  { name: "sync", label: "sync — đẩy thay đổi local lên backend" },
+  { name: "published-html", label: "published-html — build & publish trang HTML" },
+  { name: "gen-react-web-code", label: "gen-react-web-code — sinh mã React web" },
+  { name: "gen-react-mobile-code", label: "gen-react-mobile-code — sinh mã React mobile" },
+];
+
+const ALIASES = {};
+
+const SUBCOMMAND_NAMES = new Set(SUBCOMMANDS.map((s) => s.name));
+
+function requireHandler(name) {
+  // eslint-disable-next-line global-require, import/no-dynamic-require
+  return require(`./${name}`);
+}
+
+async function runSubcommand(name, args) {
+  const handler = requireHandler(name);
+  await handler.run(args);
+}
+
+async function promptMenu() {
+  const message = "pan ui — chọn hành động:";
+  const choices = SUBCOMMANDS.map((s) => ({ name: s.label, value: s.name }));
+  const hotkeys = [{ key: "x", label: t("EXIT_LABEL"), value: "exit" }];
+
+  // Menu gốc (không có cấp cha) — chỉ cần phím x thoát; nhất quán với các menu khác trong CLI
+  // (menuSelect ưu tiên; thiếu @inquirer/core → @inquirer/prompts select + item thoát ẩn).
+  try {
+    return await menuSelect({ message, choices, hotkeys });
+  } catch (err) {
+    if (String(err && err.message) !== "no-core") throw err;
+  }
+
+  const inq = await import("@inquirer/prompts").catch(() => null);
+  if (!inq || typeof inq.select !== "function") {
+    throw new Error(
+      "Không có TTY / @inquirer/prompts để hiện menu — chạy trực tiếp: pan ui <subcommand>."
+    );
+  }
+  return inq.select({
+    message,
+    choices: [
+      ...choices,
+      new inq.Separator(),
+      { name: `x  ${t("EXIT_LABEL")}`, value: "exit" },
+    ],
+    loop: false,
+  });
+}
+
+/**
+ * @param {string[]} args - vd ["clone", "--foo"] hoặc [] (menu tương tác)
+ */
+async function runUi(args) {
+  const [rawSub, ...rest] = args;
+  const maybeSub = rawSub && ALIASES[rawSub] ? ALIASES[rawSub] : rawSub;
+
+  if (maybeSub && SUBCOMMAND_NAMES.has(maybeSub)) {
+    await runSubcommand(maybeSub, rest);
+    return;
+  }
+
+  if (maybeSub) {
+    throw new Error(
+      `pan ui: subcommand không hợp lệ '${maybeSub}'. Các subcommand hợp lệ: ${[...SUBCOMMAND_NAMES].join(", ")}`
+    );
+  }
+
+  const choice = await promptMenu();
+  if (choice === "exit") {
+    return;
+  }
+  await runSubcommand(choice, []);
+}
+
+module.exports = {
+  SUBCOMMANDS,
+  runUi,
+};