sy-lowcode-workspace-tools 0.1.0 → 0.1.1

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "sy-lowcode-workspace-tools",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "CLI tools for sy lowcode app workspaces",
   "type": "module",
   "bin": {
-    "lowcode-workspace": "./bin/lowcode-workspace.mjs"
+    "lowcode-workspace": "bin/lowcode-workspace.mjs"
   },
   "exports": {
     ".": "./src/cli.mjs"

package/scripts/register.mjs

@@ -198,6 +198,7 @@ async function registerPages() {
   if (dryRun) {
     console.log("  [DRY] 代码页发布 payload:");
     console.log(JSON.stringify(payload, null, 2));
+    writePagePublishResult(payload, null, true);
     return { succeeded: pages.length, failed: 0 };
   }
 
@@ -220,9 +221,50 @@ async function registerPages() {
   body.data?.items?.forEach((item) => {
     console.log(`  ✓ 代码页 ${item.code} (${item.pageId})`);
   });
+  writePagePublishResult(payload, body, false);
   return { succeeded: pages.length, failed: 0 };
 }
 
+function writePagePublishResult(payload, responseBody, isDryRun) {
+  const publishedItems = new Map(
+    (responseBody?.data?.items || []).map((item) => [item.code, item]),
+  );
+  const result = {
+    appId: config.appId || config.appType,
+    appType: payload.appType,
+    workspacePath: rootDir,
+    version: payload.version,
+    buildId: payload.buildId,
+    pages: payload.pages.map((page) => {
+      const published = publishedItems.get(page.code) || {};
+      return {
+        code: page.code,
+        name: page.name,
+        pageId: published.pageId || (isDryRun ? "<dry-run-pageId>" : ""),
+        routeKey:
+          published.routeKey ||
+          page.route?.pathKey ||
+          page.route?.path ||
+          page.code,
+        legacyFormUuid:
+          published.legacyFormUuid || published.formUuid || null,
+        entryUrl: page.runtime?.entryUrl || "",
+        cssUrls: page.runtime?.cssUrls || [],
+        menuId:
+          published.menuId === undefined
+            ? isDryRun
+              ? "<dry-run-menuId>"
+              : null
+            : published.menuId,
+      };
+    }),
+    publishedAt: new Date().toISOString(),
+  };
+  const outputPath = path.resolve(rootDir, "dist", "publish-result.json");
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+  fs.writeFileSync(outputPath, `${JSON.stringify(result, null, 2)}\n`, "utf-8");
+}
+
 console.log(`🔗 注册应用工作区产物 (${dryRun ? "DRY RUN" : "LIVE"})`);
 console.log(`   API: ${apiBase}`);
 console.log("");

package/src/cli.mjs

@@ -39,7 +39,20 @@ const textExtensions = new Set([
   ".yml",
   ".yaml",
 ]);
-const ignoredDirs = new Set([".git", "node_modules", "dist", "build", "coverage", ".vite"]);
+const ignoredDirs = new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".vite",
+  "packages",
+]);
+const runtimePackages = [
+  "sy-form-components",
+  "sy-page-sdk",
+  "sy-lowcode-workspace-tools",
+];
 
 function usage() {
   return `
@@ -49,17 +62,24 @@ Commands:
   build | build-forms | build-pages | sync-schema | publish-oss | register | publish-all
   update   Update workspace runtime dependencies and managed wrappers
   migrate  Convert old local SDK workspace to npm package mode
+  smoke    Run workspace runtime smoke checks
 
 Update options:
   --workspace <path>       Workspace root, defaults to cwd
   --channel <tag>          npm dist-tag, defaults to latest
   --check                  Validate only; do not mutate
+  --strict-lock            Compare lockfile and installed versions with npm latest
   --commit                 Commit update changes
   --push                   Push after commit
   --no-commit              Do not commit, even if changes exist
   --allow-dirty            Allow updates with existing worktree changes
   --skip-install           Do not run pnpm install/update
   --skip-gate              Do not run typecheck smoke gate
+  --gate <quick|full>      Gate depth after update, defaults to quick
+
+Smoke options:
+  --workspace <path>       Workspace root, defaults to cwd
+  --mode <quick|full>      quick validates commands/manifests; full builds shared runtimes
 `;
 }
 
@@ -72,7 +92,7 @@ function parseArgs(argv) {
       continue;
     }
     const key = arg.slice(2);
-    if (["workspace", "channel"].includes(key)) {
+    if (["workspace", "channel", "mode", "gate"].includes(key)) {
       result[key] = argv[index + 1];
       index += 1;
     } else {
@@ -120,6 +140,68 @@ function writeJson(path, value) {
   writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
 }
 
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function readOptionalJson(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return readJson(path);
+  } catch {
+    return null;
+  }
+}
+
+function npmLatestVersion(packageName, channel) {
+  const result = run("npm", ["view", `${packageName}@${channel}`, "version"], {
+    capture: true,
+  });
+  return String(result.stdout || "").trim();
+}
+
+function readInstalledVersion(workspaceRoot, packageName) {
+  const packagePath = join(workspaceRoot, "node_modules", packageName, "package.json");
+  const pkg = readOptionalJson(packagePath);
+  return typeof pkg?.version === "string" ? pkg.version : null;
+}
+
+function readLockVersion(workspaceRoot, packageName) {
+  const lockPath = join(workspaceRoot, "pnpm-lock.yaml");
+  if (!existsSync(lockPath)) return null;
+  const content = readFileSync(lockPath, "utf-8");
+  const packagePattern = new RegExp(
+    `(?:^|\\n)\\s{2,}/?${escapeRegExp(packageName)}@([^:\\n(]+)(?:\\([^\\n]*\\))?:`,
+  );
+  const packageMatch = content.match(packagePattern);
+  if (packageMatch?.[1]) return packageMatch[1].trim();
+
+  const dependencyPattern = new RegExp(
+    `(?:^|\\n)\\s{6}${escapeRegExp(packageName)}:\\n\\s{8}specifier:\\s*[^\\n]+\\n\\s{8}version:\\s*([^\\s(]+)`,
+  );
+  const dependencyMatch = content.match(dependencyPattern);
+  return dependencyMatch?.[1]?.trim() || null;
+}
+
+function validateRuntimeManifest(workspaceRoot, manifestPath, expectedProtocol, expectedMajorVersion) {
+  if (!existsSync(manifestPath)) return;
+  const manifest = readJson(manifestPath);
+  const errors = [];
+  if (manifest.protocol !== expectedProtocol) {
+    errors.push(`protocol must be ${expectedProtocol}`);
+  }
+  if (manifest.majorVersion !== expectedMajorVersion) {
+    errors.push(`majorVersion must be ${expectedMajorVersion}`);
+  }
+  if (!manifest.version) errors.push("version is required");
+  if (!manifest.files?.entry) errors.push("files.entry is required");
+  if (errors.length) {
+    throw new Error(
+      `${manifestPath.replace(`${workspaceRoot}/`, "")} is invalid: ${errors.join("; ")}`,
+    );
+  }
+}
+
 function gitStatus(workspaceRoot) {
   const result = run("git", ["status", "--porcelain"], {
     cwd: workspaceRoot,
@@ -260,15 +342,19 @@ function removeLocalSdk(workspaceRoot) {
   }
 }
 
-function validateWorkspace(workspaceRoot, channel = "latest") {
+function validateWorkspace(workspaceRoot, channel = "latest", options = {}) {
   const errors = [];
+  const warnings = [];
   const pkg = readJson(join(workspaceRoot, "package.json"));
   const deps = pkg.dependencies || {};
   if (deps["@sy/page-sdk"]) errors.push("package.json still depends on @sy/page-sdk");
-  for (const name of ["sy-form-components", "sy-page-sdk", "sy-lowcode-workspace-tools"]) {
+  for (const name of runtimePackages) {
     if (deps[name] !== channel) errors.push(`package.json dependency ${name} must be ${channel}`);
   }
-  if (existsSync(join(workspaceRoot, "packages", "page-sdk"))) {
+  const isWorkspaceToolsSourceRepo = existsSync(
+    join(workspaceRoot, "packages", "workspace-tools", "package.json"),
+  );
+  if (existsSync(join(workspaceRoot, "packages", "page-sdk")) && !isWorkspaceToolsSourceRepo) {
     errors.push("local packages/page-sdk must be removed from application workspaces");
   }
   walkFiles(workspaceRoot, (filePath) => {
@@ -284,6 +370,41 @@ function validateWorkspace(workspaceRoot, channel = "latest") {
   if (errors.length) {
     throw new Error(`workspace update check failed:\n- ${errors.join("\n- ")}`);
   }
+  if (options.strictLock) {
+    const versionRows = [];
+    for (const packageName of runtimePackages) {
+      const latest = npmLatestVersion(packageName, channel);
+      const installed = readInstalledVersion(workspaceRoot, packageName);
+      const locked = readLockVersion(workspaceRoot, packageName);
+      versionRows.push({ packageName, latest, installed, locked });
+      if (latest && locked && locked !== latest) {
+        errors.push(`pnpm-lock.yaml locks ${packageName}@${locked}, latest is ${latest}`);
+      }
+      if (latest && installed && installed !== latest) {
+        errors.push(`node_modules has ${packageName}@${installed}, latest is ${latest}`);
+      }
+      if (!locked) {
+        warnings.push(`pnpm-lock.yaml does not contain ${packageName}; run pnpm install after update`);
+      }
+      if (!installed) {
+        warnings.push(`node_modules does not contain ${packageName}; run pnpm install`);
+      }
+    }
+    if (versionRows.length) {
+      console.log("[lowcode-workspace] runtime dependency versions:");
+      for (const row of versionRows) {
+        console.log(
+          `  - ${row.packageName}: latest=${row.latest || "unknown"} locked=${row.locked || "missing"} installed=${row.installed || "missing"}`,
+        );
+      }
+    }
+  }
+  if (errors.length) {
+    throw new Error(`workspace update check failed:\n- ${errors.join("\n- ")}`);
+  }
+  for (const warning of warnings) {
+    console.warn(`[lowcode-workspace] warning: ${warning}`);
+  }
 }
 
 function runUpdateInstall(workspaceRoot, channel) {
@@ -299,12 +420,34 @@ function runUpdateInstall(workspaceRoot, channel) {
   run("pnpm", ["install"], { cwd: workspaceRoot });
 }
 
-function runQuickGate(workspaceRoot) {
+function runSmoke(workspaceRoot, mode = "quick") {
+  const normalizedMode = String(mode || "quick").trim();
+  if (!["quick", "full"].includes(normalizedMode)) {
+    throw new Error(`unsupported smoke mode: ${mode}`);
+  }
   const pkg = readJson(join(workspaceRoot, "package.json"));
   if (pkg.scripts?.typecheck) {
     run("pnpm", ["typecheck"], { cwd: workspaceRoot });
   }
-  runManagedScript("build-pages", ["--help"], workspaceRoot);
+  if (normalizedMode === "full") {
+    runManagedScript("build-pages", ["--bundle-mode", "shared"], workspaceRoot);
+    runManagedScript("build-forms", ["--bundle-mode", "shared"], workspaceRoot);
+  } else {
+    runManagedScript("build-pages", ["--bundle-mode", "shared", "--help"], workspaceRoot);
+    runManagedScript("build-forms", ["--bundle-mode", "shared", "--help"], workspaceRoot);
+  }
+  validateRuntimeManifest(
+    workspaceRoot,
+    join(workspaceRoot, "dist", "page-runtime", "manifest.json"),
+    "sy-page-runtime",
+    1,
+  );
+  validateRuntimeManifest(
+    workspaceRoot,
+    join(workspaceRoot, "dist", "form-runtime", "manifest.json"),
+    "sy-form-runtime",
+    2,
+  );
 }
 
 function commitAndMaybePush(workspaceRoot, push) {
@@ -325,12 +468,14 @@ async function updateWorkspace(argv, { migrate = false } = {}) {
   const workspaceRoot = resolve(args.workspace || process.cwd());
   const channel = String(args.channel || process.env.APP_WORKSPACE_UPDATE_CHANNEL || "latest");
   const checkOnly = Boolean(args.check);
+  const strictLock = Boolean(args["strict-lock"]);
   const allowDirty = Boolean(args["allow-dirty"]);
   const shouldCommit = Boolean(args.commit) && !args["no-commit"];
   const shouldPush = Boolean(args.push);
+  const gateMode = String(args.gate || "quick");
 
   if (checkOnly) {
-    validateWorkspace(workspaceRoot, channel);
+    validateWorkspace(workspaceRoot, channel, { strictLock });
     console.log("[lowcode-workspace] update check passed");
     return;
   }
@@ -353,8 +498,8 @@ async function updateWorkspace(argv, { migrate = false } = {}) {
   }
 
   if (!args["skip-install"]) runUpdateInstall(workspaceRoot, channel);
-  validateWorkspace(workspaceRoot, channel);
-  if (!args["skip-gate"]) runQuickGate(workspaceRoot);
+  validateWorkspace(workspaceRoot, channel, { strictLock: true });
+  if (!args["skip-gate"]) runSmoke(workspaceRoot, gateMode);
   if (shouldCommit) commitAndMaybePush(workspaceRoot, shouldPush);
   console.log("[lowcode-workspace] workspace update completed");
 }
@@ -373,6 +518,12 @@ export async function main(argv = process.argv.slice(2)) {
     await updateWorkspace(rest, { migrate: true });
     return;
   }
+  if (command === "smoke") {
+    const args = parseArgs(rest);
+    runSmoke(resolve(args.workspace || process.cwd()), args.mode || "quick");
+    console.log("[lowcode-workspace] smoke check passed");
+    return;
+  }
   if (managedCommands.has(command)) {
     const args = parseArgs(rest);
     runManagedScript(command, rest, resolve(args.workspace || process.cwd()));