openclaw-openviking-setup-helper 0.2.10 → 0.2.12

package/install.js

@@ -11,7 +11,7 @@
  *
  * Direct run:
  *   node install.js [ -y | --yes ] [ --zh ] [ --workdir PATH ] [ --upgrade-plugin ]
- *                   [ --plugin-version=TAG ] [ --openviking-version=V ] [ --repo=PATH ]
+ *                   [ --plugin-version=TAG ] [ --openviking-version=V ] [ --version=V ] [ --repo=PATH ]
  *
  * Environment variables:
  *   REPO, PLUGIN_VERSION (or BRANCH), OPENVIKING_INSTALL_YES, SKIP_OPENCLAW, SKIP_OPENVIKING
@@ -32,8 +32,10 @@ import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 let REPO = process.env.REPO || "volcengine/OpenViking";
-// PLUGIN_VERSION takes precedence over BRANCH (legacy)
-let PLUGIN_VERSION = process.env.PLUGIN_VERSION || process.env.BRANCH || "main";
+// PLUGIN_VERSION takes precedence over BRANCH (legacy). If omitted, resolve the latest tag from GitHub.
+const pluginVersionEnv = (process.env.PLUGIN_VERSION || process.env.BRANCH || "").trim();
+let PLUGIN_VERSION = pluginVersionEnv;
+let pluginVersionExplicit = Boolean(pluginVersionEnv);
 const NPM_REGISTRY = process.env.NPM_REGISTRY || "https://registry.npmmirror.com";
 const PIP_INDEX_URL = process.env.PIP_INDEX_URL || "https://mirrors.volces.com/pypi/simple/";
 
@@ -107,6 +109,11 @@ let openvikingRepo = process.env.OPENVIKING_REPO || "";
 let workdirExplicit = false;
 let upgradePluginOnly = false;
 let rollbackLastUpgrade = false;
+let combinedVersion = "";
+let combinedVersionExplicit = false;
+let pluginVersionArgExplicit = false;
+let openvikingVersionArgExplicit = false;
+let showCurrentVersion = false;
 
 let selectedMode = "local";
 let selectedServerPort = DEFAULT_SERVER_PORT;
@@ -129,6 +136,10 @@ for (let i = 0; i < argv.length; i++) {
     langZh = true;
     continue;
   }
+  if (arg === "--current-version") {
+    showCurrentVersion = true;
+    continue;
+  }
   if (arg === "--upgrade-plugin" || arg === "--update" || arg === "--upgrade") {
     upgradePluginOnly = true;
     continue;
@@ -149,7 +160,14 @@ for (let i = 0; i < argv.length; i++) {
     continue;
   }
   if (arg.startsWith("--plugin-version=")) {
-    PLUGIN_VERSION = arg.slice("--plugin-version=".length).trim();
+    const version = arg.slice("--plugin-version=".length).trim();
+    if (!version) {
+      console.error("--plugin-version requires a value");
+      process.exit(1);
+    }
+    PLUGIN_VERSION = version;
+    pluginVersionExplicit = true;
+    pluginVersionArgExplicit = true;
     continue;
   }
   if (arg === "--plugin-version") {
@@ -159,11 +177,14 @@ for (let i = 0; i < argv.length; i++) {
       process.exit(1);
     }
     PLUGIN_VERSION = version;
+    pluginVersionExplicit = true;
+    pluginVersionArgExplicit = true;
     i += 1;
     continue;
   }
   if (arg.startsWith("--openviking-version=")) {
     openvikingVersion = arg.slice("--openviking-version=".length).trim();
+    openvikingVersionArgExplicit = true;
     continue;
   }
   if (arg === "--openviking-version") {
@@ -173,6 +194,28 @@ for (let i = 0; i < argv.length; i++) {
       process.exit(1);
     }
     openvikingVersion = version;
+    openvikingVersionArgExplicit = true;
+    i += 1;
+    continue;
+  }
+  if (arg.startsWith("--version=")) {
+    const version = arg.slice("--version=".length).trim();
+    if (!version) {
+      console.error("--version requires a value");
+      process.exit(1);
+    }
+    combinedVersion = version;
+    combinedVersionExplicit = true;
+    continue;
+  }
+  if (arg === "--version") {
+    const version = argv[i + 1]?.trim();
+    if (!version) {
+      console.error("--version requires a value");
+      process.exit(1);
+    }
+    combinedVersion = version;
+    combinedVersionExplicit = true;
     i += 1;
     continue;
   }
@@ -200,18 +243,44 @@ for (let i = 0; i < argv.length; i++) {
   }
 }
 
+if (combinedVersionExplicit) {
+  if (pluginVersionArgExplicit || openvikingVersionArgExplicit) {
+    console.error("--version cannot be used together with --plugin-version or --openviking-version");
+    process.exit(1);
+  }
+  const normalizedVersion = normalizeCombinedVersion(combinedVersion);
+  PLUGIN_VERSION = normalizedVersion.pluginVersion;
+  openvikingVersion = normalizedVersion.openvikingVersion;
+  pluginVersionExplicit = true;
+}
+
 function setOpenClawDir(dir) {
   OPENCLAW_DIR = dir;
 }
 
+function normalizeCombinedVersion(version) {
+  const value = (version || "").trim();
+  if (!/^(v)?\d+(\.\d+){1,2}$/.test(value)) {
+    console.error("--version requires a semantic version like 0.2.9 or v0.2.9");
+    process.exit(1);
+  }
+  const openvikingVersionValue = value.startsWith("v") ? value.slice(1) : value;
+  return {
+    pluginVersion: `v${openvikingVersionValue}`,
+    openvikingVersion: openvikingVersionValue,
+  };
+}
+
 function printHelp() {
   console.log("Usage: node install.js [ OPTIONS ]");
   console.log("");
   console.log("Options:");
   console.log("  --github-repo=OWNER/REPO GitHub repository (default: volcengine/OpenViking)");
-  console.log("  --plugin-version=TAG     Plugin version (Git tag, e.g. v0.2.9, default: main)");
+  console.log("  --version=V              Shorthand for --plugin-version=vV and --openviking-version=V");
+  console.log("  --plugin-version=TAG     Plugin version (Git tag, e.g. v0.2.9, default: latest tag)");
   console.log("  --openviking-version=V   OpenViking PyPI version (e.g. 0.2.9, default: latest)");
   console.log("  --workdir PATH           OpenClaw config directory (default: ~/.openclaw)");
+  console.log("  --current-version        Print installed plugin/OpenViking versions and exit");
   console.log("  --repo=PATH              Use local OpenViking repo at PATH (pip -e + local plugin)");
   console.log("  --update, --upgrade-plugin");
   console.log("                           Upgrade only the plugin to the requested --plugin-version; keep ov.conf and do not change the OpenViking service");
@@ -225,13 +294,19 @@ function printHelp() {
   console.log("  # Install latest version");
   console.log("  node install.js");
   console.log("");
+  console.log("  # Show installed versions");
+  console.log("  node install.js --current-version");
+  console.log("");
+  console.log("  # Install a specific release version");
+  console.log("  node install.js --version=0.2.9");
+  console.log("");
   console.log("  # Install from a fork repository");
   console.log("  node install.js --github-repo=yourname/OpenViking --plugin-version=dev-branch");
   console.log("");
   console.log("  # Install specific plugin version");
   console.log("  node install.js --plugin-version=v0.2.8");
   console.log("");
-  console.log("  # Upgrade only the plugin files");
+  console.log("  # Upgrade only the plugin files from main branch");
   console.log("  node install.js --update --plugin-version=main");
   console.log("");
   console.log("  # Roll back the last plugin upgrade");
@@ -433,6 +508,10 @@ async function selectWorkdir() {
 
   const instances = detectOpenClawInstances();
   if (instances.length <= 1) return;
+  if (showCurrentVersion) {
+    setOpenClawDir(instances[0]);
+    return;
+  }
   if (installYes) return;
 
   console.log("");
@@ -572,8 +651,8 @@ function ensurePluginOnlyOperationArgs() {
   if ((upgradePluginOnly || rollbackLastUpgrade) && openvikingVersion) {
     err(
       tr(
-        "Plugin-only upgrade/rollback does not support --openviking-version. Use --plugin-version to choose the plugin release, and run a full install if you need to change the OpenViking service version.",
-        "仅插件升级或回滚不支持 --openviking-version。请使用 --plugin-version 指定插件版本；如果需要调整 OpenViking 服务版本，请执行完整安装流程。",
+        "Plugin-only upgrade/rollback does not support --openviking-version or --version. Use --plugin-version to choose the plugin release, and run a full install if you need to change the OpenViking service version.",
+        "仅插件升级或回滚不支持 --openviking-version 或 --version。请使用 --plugin-version 指定插件版本；如果需要调整 OpenViking 服务版本，请执行完整安装流程。",
       ),
     );
     process.exit(1);
@@ -618,6 +697,120 @@ async function testRemoteFile(url) {
   return false;
 }
 
+function compareSemverDesc(a, b) {
+  if (versionGte(a, b) && versionGte(b, a)) {
+    return 0;
+  }
+  return versionGte(a, b) ? -1 : 1;
+}
+
+function pickLatestPluginTag(tagNames) {
+  const normalized = tagNames
+    .map((tag) => String(tag ?? "").trim())
+    .filter(Boolean);
+
+  const semverTags = normalized
+    .filter((tag) => isSemverLike(tag))
+    .sort(compareSemverDesc);
+
+  if (semverTags.length > 0) {
+    return semverTags[0];
+  }
+
+  return normalized[0] || "";
+}
+
+function parseGitLsRemoteTags(output) {
+  return String(output ?? "")
+    .split(/\r?\n/)
+    .map((line) => {
+      const match = line.match(/refs\/tags\/(.+)$/);
+      return match?.[1]?.trim() || "";
+    })
+    .filter(Boolean);
+}
+
+async function resolveDefaultPluginVersion() {
+  if (PLUGIN_VERSION) {
+    return;
+  }
+
+  info(tr(
+    `No plugin version specified; resolving latest tag from ${REPO}...`,
+    `未指定插件版本，正在解析 ${REPO} 的最新 tag...`,
+  ));
+
+  const failures = [];
+  const apiUrl = `https://api.github.com/repos/${REPO}/tags?per_page=100`;
+
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    const response = await fetch(apiUrl, {
+      headers: {
+        Accept: "application/vnd.github+json",
+        "User-Agent": "openviking-setup-helper",
+        "X-GitHub-Api-Version": "2022-11-28",
+      },
+      signal: controller.signal,
+    });
+    clearTimeout(timeoutId);
+
+    if (response.ok) {
+      const payload = await response.json().catch(() => null);
+      if (Array.isArray(payload)) {
+        const latestTag = pickLatestPluginTag(payload.map((item) => item?.name || ""));
+        if (latestTag) {
+          PLUGIN_VERSION = latestTag;
+          info(tr(
+            `Resolved default plugin version to latest tag: ${PLUGIN_VERSION}`,
+            `已将默认插件版本解析为最新 tag: ${PLUGIN_VERSION}`,
+          ));
+          return;
+        }
+      } else {
+        failures.push("GitHub tags API returned an unexpected payload");
+      }
+    } else {
+      failures.push(`GitHub tags API returned HTTP ${response.status}`);
+    }
+  } catch (error) {
+    failures.push(`GitHub tags API failed: ${String(error)}`);
+  }
+
+  const gitRef = `https://github.com/${REPO}.git`;
+  const gitResult = await runCapture("git", ["ls-remote", "--tags", "--refs", gitRef], {
+    shell: IS_WIN,
+  });
+  if (gitResult.code === 0 && gitResult.out) {
+    const latestTag = pickLatestPluginTag(parseGitLsRemoteTags(gitResult.out));
+    if (latestTag) {
+      PLUGIN_VERSION = latestTag;
+      info(tr(
+        `Resolved default plugin version via git tags: ${PLUGIN_VERSION}`,
+        `已通过 git tag 解析默认插件版本: ${PLUGIN_VERSION}`,
+      ));
+      return;
+    }
+    failures.push("git ls-remote returned no usable tags");
+  } else {
+    failures.push(`git ls-remote failed${gitResult.err ? `: ${gitResult.err}` : ""}`);
+  }
+
+  err(tr(
+    `Could not resolve the latest tag for ${REPO}.`,
+    `无法解析 ${REPO} 的最新 tag。`,
+  ));
+  console.log(tr(
+    "Please rerun with --plugin-version <tag>, or use --plugin-version main to track the branch head explicitly.",
+    "请使用 --plugin-version <tag> 重新执行；如果需要显式跟踪分支头，请使用 --plugin-version main。",
+  ));
+  if (failures.length > 0) {
+    warn(failures.join(" | "));
+  }
+  process.exit(1);
+}
+
 // Resolve plugin configuration from manifest or fallback
 async function resolvePluginConfig() {
   const ghRaw = `https://raw.githubusercontent.com/${REPO}/${PLUGIN_VERSION}`;
@@ -741,7 +934,7 @@ async function checkOpenClawCompatibility() {
   }
 
   // If user explicitly requested an old version, pass
-  if (PLUGIN_VERSION !== "main" && isSemverLike(PLUGIN_VERSION) && !versionGte(PLUGIN_VERSION, "v0.2.8")) {
+  if (isSemverLike(PLUGIN_VERSION) && !versionGte(PLUGIN_VERSION, "v0.2.8")) {
     return;
   }
 
@@ -812,9 +1005,9 @@ async function installOpenViking() {
   // Determine package spec
   const pkgSpec = openvikingVersion ? `openviking==${openvikingVersion}` : "openviking";
   if (openvikingVersion) {
-    info(tr(`Installing OpenViking ${openvikingVersion} from PyPI...`, `正在安装 OpenViking ${openvikingVersion} (PyPI)...`));
+    info(tr(`Installing or upgrading OpenViking ${openvikingVersion} from PyPI...`, `正在安装或升级 OpenViking ${openvikingVersion} (PyPI)...`));
   } else {
-    info(tr("Installing OpenViking (latest) from PyPI...", "正在安装 OpenViking (最新版) (PyPI)..."));
+    info(tr("Installing or upgrading OpenViking (latest) from PyPI...", "正在安装或升级 OpenViking (最新版) (PyPI)..."));
   }
   info(tr(`Using pip index: ${PIP_INDEX_URL}`, `使用 pip 镜像源: ${PIP_INDEX_URL}`));
 
@@ -822,7 +1015,7 @@ async function installOpenViking() {
   await runCapture(py, ["-m", "pip", "install", "--upgrade", "pip", "-q", "-i", PIP_INDEX_URL], { shell: false });
   const installResult = await runLiveCapture(
     py,
-    ["-m", "pip", "install", "--progress-bar", "on", pkgSpec, "-i", PIP_INDEX_URL],
+    ["-m", "pip", "install", "--upgrade", "--progress-bar", "on", pkgSpec, "-i", PIP_INDEX_URL],
     { shell: false },
   );
   if (installResult.code === 0) {
@@ -878,7 +1071,7 @@ async function installOpenViking() {
     await runCapture(venvPy, ["-m", "pip", "install", "--upgrade", "pip", "-q", "-i", PIP_INDEX_URL], { shell: false });
     const venvInstall = await runLiveCapture(
       venvPy,
-      ["-m", "pip", "install", "--progress-bar", "on", pkgSpec, "-i", PIP_INDEX_URL],
+      ["-m", "pip", "install", "--upgrade", "--progress-bar", "on", pkgSpec, "-i", PIP_INDEX_URL],
       { shell: false },
     );
     if (venvInstall.code === 0) {
@@ -895,7 +1088,7 @@ async function installOpenViking() {
   if (process.env.OPENVIKING_ALLOW_BREAK_SYSTEM_PACKAGES === "1") {
     const systemInstall = await runLiveCapture(
       py,
-      ["-m", "pip", "install", "--progress-bar", "on", "--break-system-packages", pkgSpec, "-i", PIP_INDEX_URL],
+      ["-m", "pip", "install", "--upgrade", "--progress-bar", "on", "--break-system-packages", pkgSpec, "-i", PIP_INDEX_URL],
       { shell: false },
     );
     if (systemInstall.code === 0) {
@@ -1006,6 +1199,66 @@ function getInstallStatePathForPlugin(pluginId) {
   return join(OPENCLAW_DIR, "extensions", pluginId, ".ov-install-state.json");
 }
 
+async function detectInstalledOpenVikingVersion() {
+  const pythonCandidates = [];
+  const configuredPython = process.env.OPENVIKING_PYTHON?.trim();
+  if (configuredPython) {
+    pythonCandidates.push(configuredPython);
+  }
+
+  const envCandidates = IS_WIN
+    ? [join(OPENCLAW_DIR, "openviking.env.ps1"), join(OPENCLAW_DIR, "openviking.env.bat")]
+    : [join(OPENCLAW_DIR, "openviking.env")];
+
+  for (const envPath of envCandidates) {
+    if (!existsSync(envPath)) continue;
+    const raw = await readFile(envPath, "utf8").catch(() => "");
+    if (!raw) continue;
+    const match = raw.match(/OPENVIKING_PYTHON(?:\s*=\s*|=)['"]?([^'"\r\n]+)['"]?/);
+    const pythonPath = match?.[1]?.trim();
+    if (pythonPath) {
+      pythonCandidates.push(pythonPath);
+    }
+  }
+
+  for (const candidate of IS_WIN ? ["py", "python", "python3"] : ["python3", "python"]) {
+    pythonCandidates.push(candidate);
+  }
+
+  const seen = new Set();
+  for (const candidate of pythonCandidates) {
+    if (!candidate || seen.has(candidate)) continue;
+    seen.add(candidate);
+    const result = await runCapture(candidate, ["-c", "import openviking; print(openviking.__version__)"], { shell: IS_WIN });
+    if (result.code === 0) {
+      return result.out.trim();
+    }
+  }
+
+  return "";
+}
+
+async function printCurrentVersionInfo() {
+  const state = await readJsonFileIfExists(getInstallStatePathForPlugin("openviking"));
+  const pluginRequestedRef = state?.requestedRef || "";
+  const pluginReleaseId = state?.releaseId || "";
+  const pluginInstalledAt = state?.installedAt || "";
+  const openvikingInstalledVersion = await detectInstalledOpenVikingVersion();
+
+  console.log("");
+  bold(tr("Installed versions", "当前已安装版本"));
+  console.log("");
+  console.log(`Target: ${OPENCLAW_DIR}`);
+  console.log(`Plugin: ${pluginReleaseId || pluginRequestedRef || "not installed"}`);
+  if (pluginRequestedRef && pluginReleaseId && pluginRequestedRef !== pluginReleaseId) {
+    console.log(`Plugin requested ref: ${pluginRequestedRef}`);
+  }
+  console.log(`OpenViking: ${openvikingInstalledVersion || "unknown"}`);
+  if (pluginInstalledAt) {
+    console.log(`Installed at: ${pluginInstalledAt}`);
+  }
+}
+
 function getUpgradeAuditDir() {
   return join(OPENCLAW_DIR, ".openviking-upgrade-backup");
 }
@@ -1947,14 +2200,19 @@ async function main() {
 
   ensurePluginOnlyOperationArgs();
   await selectWorkdir();
+  if (showCurrentVersion) {
+    await printCurrentVersionInfo();
+    return;
+  }
   if (rollbackLastUpgrade) {
     info(tr("Mode: rollback last plugin upgrade", "模式: 回滚最近一次插件升级"));
-    if (PLUGIN_VERSION !== "main") {
+    if (pluginVersionExplicit) {
       warn("--plugin-version is ignored in --rollback mode.");
     }
     await rollbackLastUpgradeOperation();
     return;
   }
+  await resolveDefaultPluginVersion();
   validateRequestedPluginVersion();
   info(tr(`Target: ${OPENCLAW_DIR}`, `目标实例: ${OPENCLAW_DIR}`));
   info(tr(`Repository: ${REPO}`, `仓库: ${REPO}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-openviking-setup-helper",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Setup helper for installing OpenViking memory plugin into OpenClaw",
   "type": "module",
   "bin": {