@lumi-ai-lab/harness-data 0.0.12 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumi-ai-lab/harness-data",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "Installer and updater for Harness Data",
   "type": "module",
   "bin": {

package/src/commands/install.js

@@ -3,9 +3,10 @@ import path from "node:path";
 import { commandExists, run } from "../lib/exec.js";
 import { writeLocalConfig, linkAgents } from "../lib/config.js";
 import { ask, askSecret, chooseAgent } from "../lib/prompt.js";
-import { resolveWorkspaceDir, writeState } from "../lib/paths.js";
+import { readUserState, resolveWorkspaceDir, writeState } from "../lib/paths.js";
 import { installToolsFromManifest, manifestDigest, readManifest } from "../lib/manifest.js";
 import { binaryName, platformKey } from "../lib/platform.js";
+import { resolveLatestManifest } from "../lib/tool-release.js";
 import { collectDoctor } from "./doctor.js";
 import { packageVersion } from "../lib/package.js";
 import { downloadReleaseAsset, findReleaseAsset, githubToken, hasGithubAuth, latestRelease } from "../lib/github.js";
@@ -15,6 +16,14 @@ import { gitUrls, runGitWithProtocol } from "../lib/git-auth.js";
 const runtimeRepo = "lumi-ai-lab/harness-data";
 const wikisRepo = "lumi-ai-lab/harness-data-wikis";
 
+function readInstallState(runtimeDir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(runtimeDir, ".harness", "installer-state.json"), "utf8"));
+  } catch {
+    return readUserState();
+  }
+}
+
 async function requireCommands(commands) {
   for (const command of commands) {
     if (!(await commandExists(command))) throw new Error(`missing required command: ${command}`);
@@ -232,14 +241,18 @@ export async function installCommand(options = {}) {
   step(3, 8, "安装 CLI 工具");
   const manifestPath = path.resolve(options.manifest || path.join(runtimeDir, "bootstrap", "cli-manifest.json"));
   const tokenMode = await hasGithubAuth(options);
+  const installState = readInstallState(runtimeDir);
 
   let manifest;
   let localTools = {};
   if (tokenMode) {
-    manifest = await installToolsFromManifest(runtimeDir, manifestPath, options);
+    manifest = readManifest(manifestPath);
+    const latestManifest = await resolveLatestManifest(manifest, key, options);
+    manifest = await installToolsFromManifest(runtimeDir, manifestPath, { ...options, state: installState, manifestOverride: latestManifest });
   } else {
     manifest = readManifest(manifestPath);
-    await installToolsFromManifest(runtimeDir, manifestPath, { ...options, tools: ["data-harness-cli"] });
+    const latestManifest = await resolveLatestManifest(manifest, key, { ...options, tools: ["data-harness-cli"] });
+    manifest = await installToolsFromManifest(runtimeDir, manifestPath, { ...options, state: installState, manifestOverride: latestManifest });
     localTools = await installLocalTools(runtimeDir, options);
   }
   ok(`${Object.keys(manifest.installedTools || {}).length + Object.keys(localTools).length} 个 CLI 已安装到 bin/`);

package/src/commands/update.js

@@ -7,6 +7,7 @@ import { installToolsFromManifest, manifestDigest, readManifest } from "../lib/m
 import { packageVersion } from "../lib/package.js";
 import { platformKey } from "../lib/platform.js";
 import { githubToken, latestRelease } from "../lib/github.js";
+import { resolveLatestTool } from "../lib/tool-release.js";
 import { protocolFromUrl, runGitWithProtocol } from "../lib/git-auth.js";
 import { buildAndCheck, installRuntimeBundle, printDoctorSummary } from "./install.js";
 import { collectDoctor } from "./doctor.js";
@@ -23,48 +24,17 @@ async function npmLatest() {
   }
 }
 
-function archiveSuffix(url) {
-  if (url.endsWith(".zip")) return "zip";
-  if (url.endsWith(".tar.gz")) return "tar.gz";
-  return "";
-}
-
-function toolAssetName(tool, tag, key) {
-  const current = tool.platforms?.[key]?.url || "";
-  const suffix = archiveSuffix(current) || (key.startsWith("windows-") ? "zip" : "tar.gz");
-  return `${tool.binary}-${tag}-${key}.${suffix}`;
-}
-
-function releaseAsset(release, name) {
-  return (release.assets || []).find((asset) => asset.name === name);
-}
-
-function oneToolManifest(manifest, tool, tag, asset, key) {
+function oneToolManifest(manifest, tool) {
   return {
     ...manifest,
-    tools: [{
-      ...tool,
-      version: tag,
-      platforms: {
-        [key]: {
-          url: asset.browser_download_url || `https://github.com/${tool.repo}/releases/download/${tag}/${asset.name}`,
-          sha256: ""
-        }
-      }
-    }]
+    tools: [tool]
   };
 }
 
 async function maybeUpdateTool(runtimeDir, manifest, tool, options, state) {
   const key = platformKey();
-  const release = await latestRelease(tool.repo, options);
-  const tag = release.tag_name;
-  const assetName = toolAssetName(tool, tag, key);
-  const asset = releaseAsset(release, assetName);
-  if (!asset) {
-    warn(`${tool.name} 最新 release 缺少 ${assetName}，已跳过`);
-    return null;
-  }
+  const latestTool = await resolveLatestTool(tool, key, options);
+  const tag = latestTool.version;
   const current = state.tools?.[tool.name] || {};
   const tagChanged = current.version && current.version !== tag;
   const firstInstall = !current.version;
@@ -78,12 +48,12 @@ async function maybeUpdateTool(runtimeDir, manifest, tool, options, state) {
     options.skippedUpdates?.push(`${tool.name} ${tag}`);
     return null;
   }
-  const updatedManifest = oneToolManifest(manifest, tool, tag, asset, key);
+  const updatedManifest = oneToolManifest(manifest, latestTool);
   const installed = await installToolsFromManifest(runtimeDir, path.join(runtimeDir, ".bootstrap-cache", `${tool.name}-manifest.json`), {
     ...options,
     manifestOverride: updatedManifest
   });
-  const result = installed.installedTools?.[tool.name] || { version: tag, asset: assetName };
+  const result = installed.installedTools?.[tool.name] || { version: tag };
   ok(`${tool.name} 已更新到 ${tag}`);
   return result;
 }

package/src/lib/manifest.js

@@ -4,7 +4,7 @@ import https from "node:https";
 import path from "node:path";
 import { commandExists, run } from "./exec.js";
 import { platformKey } from "./platform.js";
-import { action, warn } from "./log.js";
+import { action, skip, warn } from "./log.js";
 
 export function readManifest(file) {
   return JSON.parse(fs.readFileSync(file, "utf8"));
@@ -136,6 +136,35 @@ function fileSha256(file) {
   return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
 }
 
+function executable(file) {
+  try {
+    fs.accessSync(file, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function reusableInstalledTool(workspace, tool, asset, options = {}) {
+  const current = tool.version ? optionsStateTool(options, tool.name) : null;
+  if (!current?.version || current.version !== tool.version) return null;
+  if (!current.sha256) return null;
+  const binary = path.join(workspace, "bin", tool.binary);
+  if (!executable(binary)) return null;
+  const actualSha = fileSha256(binary);
+  if (actualSha !== current.sha256) return null;
+  return {
+    version: current.version,
+    asset: current.asset || assetName(asset),
+    sha256: current.sha256,
+    ...(current.assetSha256 ? { assetSha256: current.assetSha256 } : {})
+  };
+}
+
+function optionsStateTool(options, name) {
+  return options?.state?.tools?.[name] || null;
+}
+
 export async function installToolsFromManifest(workspace, manifestPath, options = {}) {
   const manifest = options.manifestOverride || readManifest(manifestPath);
   const only = options.tools ? new Set(options.tools) : null;
@@ -150,6 +179,12 @@ export async function installToolsFromManifest(workspace, manifestPath, options
     if (only && !only.has(tool.name)) continue;
     const asset = tool.platforms?.[key];
     if (!asset?.url) throw new Error(`manifest missing ${tool.name} asset for ${key}`);
+    const reusable = !options.force ? reusableInstalledTool(workspace, tool, asset, options) : null;
+    if (reusable) {
+      if (options.log !== false) skip(`${tool.name} 已是最新 ${tool.version}`);
+      installedTools[tool.name] = reusable;
+      continue;
+    }
     const archive = path.join(cacheDir, assetName(asset));
     if (options.log !== false) action(`下载 ${tool.name} ${tool.version} (${key})`);
     await downloadAsset(tool, asset, archive, options);
@@ -165,10 +200,12 @@ export async function installToolsFromManifest(workspace, manifestPath, options
     const binary = path.join(binDir, tool.binary);
     if (!fs.existsSync(binary)) throw new Error(`${tool.binary} was not extracted to bin/`);
     fs.chmodSync(binary, 0o755);
+    const binarySha = fileSha256(binary);
     installedTools[tool.name] = {
       version: tool.version || "",
       asset: assetName(asset),
-      sha256: sha || actualSha
+      sha256: binarySha,
+      assetSha256: sha || actualSha
     };
   }
   Object.defineProperty(manifest, "installedTools", { value: installedTools, enumerable: false });

package/src/lib/tool-release.js

@@ -0,0 +1,47 @@
+import { latestRelease } from "./github.js";
+
+function archiveSuffix(asset, key) {
+  if (asset?.archive) return asset.archive;
+  if (asset?.url?.endsWith(".zip")) return "zip";
+  if (asset?.url?.endsWith(".tar.gz")) return "tar.gz";
+  return key.startsWith("windows-") ? "zip" : "tar.gz";
+}
+
+export function toolAssetName(tool, tag, key) {
+  const suffix = archiveSuffix(tool.platforms?.[key], key);
+  return `${tool.binary}-${tag}-${key}.${suffix}`;
+}
+
+export function releaseAsset(release, name) {
+  return (release.assets || []).find((asset) => asset.name === name);
+}
+
+export async function resolveLatestTool(tool, key, options = {}) {
+  const release = await latestRelease(tool.repo, options);
+  const tag = release.tag_name;
+  const name = toolAssetName(tool, tag, key);
+  const asset = releaseAsset(release, name);
+  if (!asset) {
+    throw new Error(`${tool.name} latest release ${tag} missing ${key} asset in ${tool.repo}: ${name}`);
+  }
+  return {
+    ...tool,
+    version: tag,
+    platforms: {
+      [key]: {
+        url: asset.browser_download_url || `https://github.com/${tool.repo}/releases/download/${tag}/${asset.name}`,
+        sha256: ""
+      }
+    }
+  };
+}
+
+export async function resolveLatestManifest(manifest, key, options = {}) {
+  const only = options.tools ? new Set(options.tools) : null;
+  const tools = [];
+  for (const tool of manifest.tools || []) {
+    if (only && !only.has(tool.name)) continue;
+    tools.push(await resolveLatestTool(tool, key, options));
+  }
+  return { ...manifest, tools };
+}