@guandata/guanwf 0.1.834 → 0.1.836

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## @guandata/guanwf 0.1.836 - 2026-09-19
+
+- 安装包按平台拆分：主包只保留启动器、Skill 与文档，原生程序由同版本的 `@guandata/guanwf-<平台>-<架构>` 可选依赖提供，安装时只下载当前系统的一份，安装命令与 CLI 行为不变。
+- 平台包缺失或主包与平台包版本不一致时给出可操作提示；新增 `pack:all`、`verify:platforms` 与自动选包/注册表门禁，发布前校验五个平台包。
+
+## @guandata/guanwf 0.1.835 - 2026-09-18
+
+- 修复 Python 镜像版本解析：优先通过 `/api/python-images/list` 读取 `pythonVersion`，旧接口不可用时降级到 `/api/system-images/list?type=PYTHON` 并解析 `runtimeEnv`；两类结构化版本字段都缺失或无法识别时才回退产品兼容契约 Python 3.8，仍然禁止从镜像描述、名称或 URL 推断版本。
+
 ## @guandata/guanwf 0.1.834 - 2026-09-17
 
 - `schedule set --failure-strategy` 改为已废弃的兼容参数，仅接受 `CONTINUE`；显式传 `END` 会在本地校验阶段失败且不发送写请求，节点失败后的后继调度由 `FAILURE` / `ALL` 连线决定。

package/README.md

@@ -46,8 +46,18 @@ guanwf install-skill
 
 > `npm install -g --foreground-scripts @guandata/guanwf` / `npm link --foreground-scripts` 会通过 postinstall 自动刷新 skill，并显示明确的成功、失败或跳过结果；上述 `guanwf install-skill` 仅用于失败后的手动修复或排查。CI 等无需 skill 的环境可设 `GUAN_SKIP_INSTALL_SKILL=1` 跳过。
 
+安装包会通过 npm `optionalDependencies` 自动选择当前系统的原生二进制。不要使用 `--omit=optional` 或 `optional=false`；企业 npm 镜像也需要同步对应的 `@guandata/guanwf-<平台>-<架构>` 包。若平台包缺失，CLI 会显示对应包名和重新安装方法。
+
 ## 版本更新
 
+### @guandata/guanwf 0.1.836
+
+- 安装时自动选择当前系统和架构的原生程序，减少下载量与磁盘占用，原有安装命令不变；离线安装也支持自动选包。
+
+### @guandata/guanwf 0.1.835
+
+- 修复 Python 镜像版本解析：优先读取 `pythonVersion`，旧接口降级解析 `runtimeEnv`，两者都不可用时才回退兼容契约 Python 3.8。
+
 ### @guandata/guanwf 0.1.834
 
 - `schedule set --failure-strategy` 仅接受 `CONTINUE`，显式传 `END` 会在本地校验阶段失败；后继调度改由 `FAILURE` / `ALL` 连线决定。

package/bin/platforms.js

@@ -0,0 +1,44 @@
+"use strict";
+
+// Single source of truth for the optionalDependencies platform-package split.
+// bin/run.js, scripts/build.js and the build/preflight tests all read this file
+// so that the matrix, the package names and the embedded binary names can never
+// drift apart.
+
+const PACKAGE_PREFIX = "@guandata/guanwf";
+const CLI_NAME = "guanwf";
+const BINARY_NAMES = ["guanwf"];
+
+const PLATFORM_TARGETS = [
+  { platform: "darwin", arch: "arm64", suffix: "darwin-arm64", ext: "" },
+  { platform: "darwin", arch: "x64", suffix: "darwin-x64", ext: "" },
+  { platform: "linux", arch: "x64", suffix: "linux-x64", ext: "" },
+  { platform: "linux", arch: "arm64", suffix: "linux-arm64", ext: "" },
+  { platform: "win32", arch: "x64", suffix: "win32-x64", ext: ".exe" },
+].map((target) => ({
+  ...target,
+  key: `${target.platform}-${target.arch}`,
+  packageName: `${PACKAGE_PREFIX}-${target.suffix}`,
+  binaries: BINARY_NAMES.map((name) => `${name}${target.ext}`),
+}));
+
+function targetForRuntime(platform, arch) {
+  return PLATFORM_TARGETS.find(
+    (target) => target.platform === platform && target.arch === arch
+  );
+}
+
+function optionalDependencies(version) {
+  return Object.fromEntries(
+    PLATFORM_TARGETS.map((target) => [target.packageName, version])
+  );
+}
+
+module.exports = {
+  CLI_NAME,
+  PACKAGE_PREFIX,
+  BINARY_NAMES,
+  PLATFORM_TARGETS,
+  optionalDependencies,
+  targetForRuntime,
+};

package/bin/run.js

@@ -7,34 +7,79 @@ const path = require("path");
 const fs = require("fs");
 const os = require("os");
 const { createInstallChildEnv, reexecInstallCommand } = require("./install-env");
-
-const PLATFORM_MAP = {
-  "darwin-arm64": "guanwf-darwin-arm64",
-  "darwin-x64": "guanwf-darwin-x64",
-  "linux-x64": "guanwf-linux-x64",
-  "linux-arm64": "guanwf-linux-arm64",
-  "win32-x64": "guanwf-win32-x64.exe",
-};
-
-function getBinaryPath() {
-  const key = `${process.platform}-${process.arch}`;
-  const binaryName = PLATFORM_MAP[key];
-  if (!binaryName) {
-    console.error(
-      `Unsupported platform: ${key}\nSupported: ${Object.keys(PLATFORM_MAP).join(", ")}`
+const {
+  BINARY_NAMES,
+  PACKAGE_PREFIX,
+  PLATFORM_TARGETS,
+  targetForRuntime,
+} = require("./platforms");
+
+// The native binaries are delivered by per-platform optional dependencies, so
+// an installation only downloads and unpacks the current OS/architecture.
+function resolvePlatformBinaries(options = {}) {
+  const platform = options.platform || process.platform;
+  const arch = options.arch || process.arch;
+  const resolvePackage = options.resolvePackage || require.resolve;
+  const exists = options.exists || fs.existsSync;
+  const readJson =
+    options.readJson || ((filename) => JSON.parse(fs.readFileSync(filename, "utf8")));
+  const key = `${platform}-${arch}`;
+  const target = targetForRuntime(platform, arch);
+  if (!target) {
+    throw new Error(
+      `Unsupported platform: ${key}\nSupported: ${PLATFORM_TARGETS.map((item) => item.key).join(", ")}`
     );
-    process.exit(1);
   }
 
-  const binaryPath = path.join(__dirname, "..", "binaries", binaryName);
-  if (!fs.existsSync(binaryPath)) {
-    console.error(
-      `Binary not found: ${binaryPath}\nRun 'npm run build' to compile binaries.`
-    );
-    process.exit(1);
+  try {
+    const packageJson = resolvePackage(`${target.packageName}/package.json`);
+    const platformVersion = readJson(packageJson).version;
+    const mainVersion = readJson(path.join(__dirname, "..", "package.json")).version;
+    if (platformVersion !== mainVersion) {
+      throw new Error(
+        `Platform package ${target.packageName} version ${platformVersion} does not match ` +
+          `${PACKAGE_PREFIX} ${mainVersion}. Reinstall ${PACKAGE_PREFIX}.`
+      );
+    }
+    const binDir = path.join(path.dirname(packageJson), "bin");
+    const binaryPaths = {};
+    for (const binary of target.binaries) {
+      const binaryPath = path.join(binDir, binary);
+      if (!exists(binaryPath)) {
+        throw new Error(
+          `Platform package ${target.packageName} is installed but its binary is missing: ${binaryPath}. ` +
+            `Reinstall ${PACKAGE_PREFIX}.`
+        );
+      }
+      binaryPaths[binary.replace(/\.exe$/, "")] = binaryPath;
+    }
+    return { target, binaryPaths };
+  } catch (err) {
+    if (err.message && err.message.startsWith("Platform package ")) throw err;
+
+    // Local development fallback. The generated directory is excluded from
+    // the published main package, so installed users always use the optional
+    // platform dependency above.
+    const localBinDir = path.join(__dirname, "..", "platforms", target.suffix, "bin");
+    const binaryPaths = {};
+    for (const binary of target.binaries) {
+      const binaryPath = path.join(localBinDir, binary);
+      if (!exists(binaryPath)) {
+        throw new Error(
+          `Missing optional platform package ${target.packageName} for ${key}.\n` +
+            `Reinstall without disabling optional dependencies:\n` +
+            `  npm install -g ${PACKAGE_PREFIX}\n` +
+            `If you used --omit=optional or optional=false, remove that setting first.`
+        );
+      }
+      binaryPaths[binary.replace(/\.exe$/, "")] = binaryPath;
+    }
+    return { target, binaryPaths };
   }
+}
 
-  return binaryPath;
+function getBinaryPath(options = {}) {
+  return resolvePlatformBinaries(options).binaryPaths[BINARY_NAMES[0]];
 }
 
 function copyDirectory(src, dest) {
@@ -81,7 +126,7 @@ function installBuddySkills(pkgRoot, skill) {
   }
 }
 
-if (process.argv[2] === "version" && process.argv.length === 3) {
+if (require.main === module && process.argv[2] === "version" && process.argv.length === 3) {
   const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
   console.log(pkg.version);
   process.exit(0);
@@ -111,7 +156,7 @@ function resolveNpxInvocation() {
   return { command: "npx", argsPrefix: [] };
 }
 
-if (process.argv[2] === "install-skill") {
+if (require.main === module && process.argv[2] === "install-skill") {
   reexecInstallCommand(__filename, process.argv.slice(2));
   const pkgRoot = path.join(__dirname, "..");
   const extraArgs = process.argv.slice(3);
@@ -143,28 +188,38 @@ if (process.argv[2] === "install-skill") {
   process.exit(status);
 }
 
-const binary = getBinaryPath();
+if (require.main === module) {
+  let binary;
+  try {
+    binary = getBinaryPath();
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
 
-try {
-  if (process.platform !== "win32") {
-    fs.chmodSync(binary, 0o755);
+  try {
+    if (process.platform !== "win32") {
+      fs.chmodSync(binary, 0o755);
+    }
+  } catch (_) {
+    // chmod may fail in read-only environments
   }
-} catch (_) {
-  // chmod may fail in read-only environments
-}
 
-if (process.platform === "win32") {
-  try { execSync("chcp 65001", { stdio: "ignore" }); } catch (_) {}
-}
+  if (process.platform === "win32") {
+    try { execSync("chcp 65001", { stdio: "ignore" }); } catch (_) {}
+  }
 
-try {
-  execFileSync(binary, process.argv.slice(2), {
-    stdio: "inherit",
-    env: { ...process.env, GUANWF_PROG_NAME: "guanwf" },
-  });
-} catch (err) {
-  if (err.status != null) {
-    process.exit(err.status);
+  try {
+    execFileSync(binary, process.argv.slice(2), {
+      stdio: "inherit",
+      env: { ...process.env, GUANWF_PROG_NAME: "guanwf" },
+    });
+  } catch (err) {
+    if (err.status != null) {
+      process.exit(err.status);
+    }
+    throw err;
   }
-  throw err;
 }
+
+module.exports = { getBinaryPath, resolvePlatformBinaries };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guandata/guanwf",
-  "version": "0.1.834",
+  "version": "0.1.836",
   "description": "观远工作流数据流编辑工具 - 创建、编辑、导出、预览、保存数据流",
   "bin": {
     "guanwf": "bin/run.js"
@@ -8,13 +8,17 @@
   "scripts": {
     "postinstall": "node bin/postinstall.js",
     "build": "node scripts/build.js && node scripts/sync-skill.js",
+    "pack:all": "node scripts/pack-all.js",
+    "test:build-script": "node scripts/platform-tests.js build && node scripts/platform-tests.js run",
+    "test:package-layout": "node scripts/platform-tests.js layout && node scripts/platform-tests.js install-smoke",
+    "test:auto-select": "node scripts/platform-tests.js auto-select",
+    "verify:platforms": "node scripts/verify-platforms.js",
     "changelog": "node ../../scripts/generate-release-changelog.js .",
     "check-changelog": "node ../../scripts/check-release-changelog.js .",
-    "prepublishOnly": "npm run check-changelog && npm run build && node scripts/preflight.js"
+    "prepublishOnly": "npm run test:build-script && npm run check-changelog && npm run build && node scripts/preflight.js && npm run test:package-layout && npm run test:auto-select"
   },
   "files": [
     "bin/",
-    "binaries/",
     "skills/",
     "CHANGELOG.md",
     "LICENSE",
@@ -37,7 +41,15 @@
   "engines": {
     "node": ">=14"
   },
+  "optionalDependencies": {
+    "@guandata/guanwf-darwin-arm64": "0.1.836",
+    "@guandata/guanwf-darwin-x64": "0.1.836",
+    "@guandata/guanwf-linux-x64": "0.1.836",
+    "@guandata/guanwf-linux-arm64": "0.1.836",
+    "@guandata/guanwf-win32-x64": "0.1.836"
+  },
   "publishConfig": {
-    "registry": "https://registry.npmjs.org/"
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
   }
 }

package/skills/guanwf/SKILL.md

@@ -169,7 +169,9 @@ guanwf python-runtime --dir <workdir> --format json
 `pythonVersionSource`、`imageId` 及解析状态，并写入 `<workdir>/_python_runtime_context.json`。`guanwf edit` 检测到
 Python 节点时也会自动获取并返回同一结构化上下文。生成代码时只以其中的
 `pythonRuntime.nodes[].runtime.pythonVersion`（或 `pythonRuntime.selected`）为兼容目标；
-当前接口没有正式版本字段时使用产品兼容契约 Python 3.8，并明确标记
+CLI 优先通过 `/api/python-images/list` 读取 `pythonVersion`；旧接口不可用时降级到
+`/api/system-images/list?type=PYTHON` 并解析 `runtimeEnv`。两类结构化版本字段均缺失或无法识别时，
+使用产品兼容契约 Python 3.8，并明确标记
 `pythonVersionSource: "compatibility_fallback"`；**禁止从镜像描述、名称或 URL 推断版本**。
 结构化上下文中的 `imageUrl` 会移除 userinfo、fragment 和敏感 query；落盘文件使用 0600 并自动忽略。
 固定 Runtime 输出 `runtimeMode: "FIXED_RUNTIME"`，配置镜像的动态 Pod 输出 `runtimeMode: "DYNAMIC_POD"`；

package/skills/guanwf/references/WORKFLOW_DSL.md

@@ -154,10 +154,12 @@ guanwf python-runtime --dir <workdir> --format json
 `pythonRuntime.nodes[]` 是工作区各 Python 节点根据 `PythonConfig.ImageID` 解析出的实际选择。
 兼容性判断以 `runtimeMode` 和嵌套 `runtime.pythonVersion` 为准，并检查 `runtime.pythonVersionSource`。CLI 不输出
 服务端自由文本 `imageDescription`；经过凭证脱敏的 `imageUrl` 仅供排查，禁止从中推断版本。
-CLI 会优先调用新版系统镜像 API，并自动兼容旧环境的 Python 镜像 API。
+CLI 优先调用兼容接口 `/api/python-images/list` 获取逐镜像 `pythonVersion`；该接口不可用时降级调用
+`/api/system-images/list?type=PYTHON`，并从规范字段 `runtimeEnv`（例如 `Python 3.11`）解析版本。
 
-短期兼容约定：镜像 API 尚未提供正式 `pythonVersion` 字段时，CLI 返回 Python 3.8，并标记
-`pythonVersionSource: "compatibility_fallback"`；若未来 API 返回正式字段，则优先使用并标记为 `api_field`。
+兼容约定：旧接口的 `pythonVersion` 或新接口的合法 `runtimeEnv` 均标记为
+`pythonVersionSource: "api_field"`；两者均缺失或 `runtimeEnv` 无法识别时，CLI 返回 Python 3.8，并标记
+`pythonVersionSource: "compatibility_fallback"`。
 
 固定 Runtime 标记 `runtimeMode: "FIXED_RUNTIME"`，配置镜像的动态 Pod 标记
 `runtimeMode: "DYNAMIC_POD"`。目录接口不可用或版本字段缺失时，状态与 warning 会明确说明，