@lumi-ai-lab/harness-data 0.0.5 → 0.0.6

package/package.json

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

package/src/commands/install.js

@@ -9,6 +9,8 @@ import { binaryName, platformKey } from "../lib/platform.js";
 import { collectDoctor } from "./doctor.js";
 import { packageVersion } from "../lib/package.js";
 import { downloadReleaseAsset, findReleaseAsset, githubToken, hasGithubAuth, latestRelease } from "../lib/github.js";
+import { action, blank, fail, header, ok, shortSha, skip, step, warn } from "../lib/log.js";
+import { gitUrls, runGitWithProtocol } from "../lib/git-auth.js";
 
 const runtimeRepo = "lumi-ai-lab/harness-data";
 const wikisRepo = "lumi-ai-lab/harness-data-wikis";
@@ -17,6 +19,7 @@ async function requireCommands(commands) {
   for (const command of commands) {
     if (!(await commandExists(command))) throw new Error(`missing required command: ${command}`);
   }
+  ok(commands.join(", "));
 }
 
 async function prepareRuntimeDir(options) {
@@ -29,6 +32,7 @@ export async function installRuntimeBundle(runtimeDir, options = {}) {
   if (!options.force && fs.existsSync(path.join(runtimeDir, "agents")) &&
       fs.existsSync(path.join(runtimeDir, "config")) &&
       fs.existsSync(path.join(runtimeDir, "bootstrap", "cli-manifest.json"))) {
+    skip("runtime bundle 已存在");
     return { tag: "", skipped: true };
   }
 
@@ -42,6 +46,7 @@ export async function installRuntimeBundle(runtimeDir, options = {}) {
   const cacheDir = path.join(runtimeDir, ".bootstrap-cache");
   fs.mkdirSync(cacheDir, { recursive: true });
   const archive = path.join(cacheDir, assetName);
+  action(`下载 harness-data-runtime ${tag}`);
   await downloadReleaseAsset(asset, archive, options);
   if (shaAsset) {
     const shaFile = `${archive}.sha256`;
@@ -51,11 +56,11 @@ export async function installRuntimeBundle(runtimeDir, options = {}) {
     const actual = crypto.createHash("sha256").update(fs.readFileSync(archive)).digest("hex");
     if (expected && actual !== expected) throw new Error("runtime bundle sha256 mismatch");
   } else {
-    console.warn("warning: runtime bundle has no sha256 asset; continuing without checksum");
+    warn("runtime bundle 未提供 sha256，已继续安装");
   }
 
   const extractDir = fs.mkdtempSync(path.join(cacheDir, "runtime-"));
-  await run("tar", ["-xzf", archive, "-C", extractDir], { stdio: "inherit" });
+  await run("tar", ["-xzf", archive, "-C", extractDir]);
   for (const dir of ["agents", "bootstrap"]) {
     const source = path.join(extractDir, dir);
     if (!fs.existsSync(source)) throw new Error(`runtime bundle missing ${dir}/`);
@@ -69,6 +74,7 @@ export async function installRuntimeBundle(runtimeDir, options = {}) {
     fs.copyFileSync(path.join(configSource, file), path.join(runtimeDir, "config", file));
   }
   fs.rmSync(extractDir, { recursive: true, force: true });
+  ok(`runtime bundle ${tag}`);
   return { tag, skipped: false };
 }
 
@@ -83,8 +89,11 @@ function executable(file) {
 
 async function promptExecutable(runtimeDir, name, options = {}) {
   const auto = path.join(runtimeDir, "bin", binaryName(name));
-  if (executable(auto)) return auto;
-  const value = await ask(`Path to ${name}:`, options);
+  if (executable(auto)) {
+    ok(`自动识别 ${name}: ${auto}`);
+    return auto;
+  }
+  const value = await ask(`请输入 ${name} 的绝对路径：`, options);
   const file = path.resolve(value);
   if (!executable(file)) throw new Error(`${name} path is missing or not executable: ${file}`);
   return file;
@@ -110,30 +119,35 @@ async function installWikis(runtimeDir, options = {}) {
   const target = path.join(runtimeDir, "wikis");
   if (githubToken(options)) {
     if (fs.existsSync(path.join(target, ".git"))) {
-      await run("git", ["-C", target, "pull", "--ff-only"], { stdio: "inherit" });
+      await runGitWithProtocol("https", ["-C", target, "pull", "--ff-only"], options);
     } else {
       fs.rmSync(target, { recursive: true, force: true });
-      await run("git", ["clone", `https://x-access-token:${githubToken(options)}@github.com/${wikisRepo}.git`, target], { stdio: "inherit" });
+      await runGitWithProtocol("https", ["clone", gitUrls.https.wikis, target], options);
     }
-    return { mode: "github", path: target };
+    const commit = (await run("git", ["-C", target, "rev-parse", "HEAD"])).stdout.trim();
+    ok(`harness-data-wikis ${shortSha(commit)}`);
+    return { mode: "github", path: target, commit };
   }
   if (await hasGithubAuth(options)) {
     if (fs.existsSync(path.join(target, ".git"))) {
-      await run("git", ["-C", target, "pull", "--ff-only"], { stdio: "inherit" });
+      await run("git", ["-C", target, "pull", "--ff-only"]);
     } else {
       fs.rmSync(target, { recursive: true, force: true });
-      await run("gh", ["repo", "clone", wikisRepo, target], { stdio: "inherit" });
+      await run("gh", ["repo", "clone", wikisRepo, target]);
     }
-    return { mode: "github", path: target };
+    const commit = (await run("git", ["-C", target, "rev-parse", "HEAD"])).stdout.trim();
+    ok(`harness-data-wikis ${shortSha(commit)}`);
+    return { mode: "github", path: target, commit };
   }
 
   const auto = path.join(runtimeDir, "harness-data-wikis");
-  const source = fs.existsSync(auto) ? auto : path.resolve(await ask("Path to harness-data-wikis:", options));
+  const source = fs.existsSync(auto) ? auto : path.resolve(await ask("请输入 harness-data-wikis 的绝对路径：", options));
   for (const dir of ["spec", "playbooks", "templates"]) {
     if (!fs.existsSync(path.join(source, dir))) throw new Error(`harness-data-wikis missing ${dir}/: ${source}`);
   }
   fs.rmSync(target, { recursive: true, force: true });
   fs.cpSync(source, target, { recursive: true });
+  ok(`harness-data-wikis 本地路径 ${source}`);
   return { mode: "local-path", source, path: target };
 }
 
@@ -142,12 +156,13 @@ function casConfigDir(runtimeDir) {
 }
 
 async function writeCasCredentials(runtimeDir, options = {}) {
-  const username = await ask("CAS username:", options);
-  const password = await askSecret("CAS password:", options);
+  const username = await ask("CAS 用户名：", options);
+  const password = await askSecret("CAS 密码：", options);
   if (!username || !password) throw new Error("CAS username and password are required");
   const dir = casConfigDir(runtimeDir);
   fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
   fs.writeFileSync(path.join(dir, "config.json"), `${JSON.stringify({ cas: { username, password } }, null, 2)}\n`, { mode: 0o600 });
+  ok("CAS 凭证已保存到 .qdm-auth/cas/config.json");
   return dir;
 }
 
@@ -155,24 +170,66 @@ async function configureTokens(runtimeDir, casDir) {
   const env = { QDM_CAS_CONFIG_DIR: casDir };
   const bin = (name) => path.join(runtimeDir, "bin", binaryName(name));
   const cmrToken = (await run(bin("cas-cli"), ["token", "--app", "cmr"], { cwd: runtimeDir, env })).stdout.trim();
-  await run(bin("qdm-cmr-cli"), ["config", "set-token", cmrToken], { cwd: runtimeDir, env, stdio: "inherit" });
+  await run(bin("qdm-cmr-cli"), ["config", "set-token", cmrToken], { cwd: runtimeDir, env });
+  ok("CMR Token 已配置");
   const indicatorsToken = (await run(bin("cas-cli"), ["token", "--app", "indicators"], { cwd: runtimeDir, env })).stdout.trim();
-  await run(bin("qdm-indicators-cli"), ["config", "set-token", indicatorsToken], { cwd: runtimeDir, env, stdio: "inherit" });
-  await run(bin("qdm-cmr-cli"), ["config", "check-token"], { cwd: runtimeDir, env, stdio: "inherit" });
-  await run(bin("qdm-indicators-cli"), ["config", "check-token"], { cwd: runtimeDir, env, stdio: "inherit" });
+  await run(bin("qdm-indicators-cli"), ["config", "set-token", indicatorsToken], { cwd: runtimeDir, env });
+  ok("Indicators Token 已配置");
+  await run(bin("qdm-cmr-cli"), ["config", "check-token"], { cwd: runtimeDir, env });
+  await run(bin("qdm-indicators-cli"), ["config", "check-token"], { cwd: runtimeDir, env });
 }
 
 export async function buildAndCheck(runtimeDir, options = {}) {
   const cli = path.join(runtimeDir, "bin", binaryName("data-harness-cli"));
-  const result = await run(cli, ["wikis", "build-index", "--skip-checks"], { cwd: runtimeDir, stdio: "inherit", allowFailure: true });
-  if (result.code !== 0) console.warn("warning: wikis build-index --skip-checks failed; continue install and retry manually later");
+  action("执行：data-harness-cli wikis build-index --skip-checks");
+  const result = await run(cli, ["wikis", "build-index", "--skip-checks"], { cwd: runtimeDir, allowFailure: true });
+  if (result.code !== 0) {
+    warn("wikis 索引构建失败，安装会继续；后续可手动执行 data-harness-cli wikis build-index --skip-checks");
+    return { ok: false };
+  }
+  const output = `${result.stdout}\n${result.stderr}`;
+  const docs = output.match(/\bdocs=(\d+)/)?.[1];
+  const recall = output.match(/\brecall=(\d+)/)?.[1];
+  const runtimeDocs = output.match(/\bruntimeDocs=(\d+)/)?.[1];
+  ok([docs ? `docs=${docs}` : "", recall ? `recall=${recall}` : "", runtimeDocs ? `runtimeDocs=${runtimeDocs}` : ""].filter(Boolean).join(", ") || "Wikis 索引已构建");
+  return { ok: true, docs, recall, runtimeDocs };
+}
+
+export function printDoctorSummary(doctor) {
+  const failed = doctor.checks.filter((check) => !check.ok);
+  if (!failed.length) {
+    ok("runtime");
+    ok("wikis/spec");
+    ok("wikis/playbooks");
+    ok("wikis/templates");
+    ok("4 个 CLI");
+    ok("本地配置");
+    ok("CAS 凭证");
+    ok("CMR Token");
+    ok("Indicators Token");
+    ok("Agent Hook");
+    return;
+  }
+  for (const check of failed) fail(`${check.name}${check.detail ? ` (${check.detail})` : ""}`);
 }
 
 export async function installCommand(options = {}) {
-  platformKey();
+  const key = platformKey();
+  header("Harness Data 安装器", packageVersion(), [
+    `安装目录：${resolveWorkspaceDir(options.dir || process.cwd())}`,
+    `平台：${key}`
+  ]);
+
+  step(1, 8, "检查本机依赖");
   await requireCommands(["git", "tar", "unzip"]);
+  blank();
+
+  step(2, 8, "安装 runtime bundle");
   const runtimeDir = await prepareRuntimeDir(options);
   const bundle = await installRuntimeBundle(runtimeDir, options);
+  blank();
+
+  step(3, 8, "安装 CLI 工具");
   const manifestPath = path.resolve(options.manifest || path.join(runtimeDir, "bootstrap", "cli-manifest.json"));
   const tokenMode = await hasGithubAuth(options);
 
@@ -185,17 +242,40 @@ export async function installCommand(options = {}) {
     await installToolsFromManifest(runtimeDir, manifestPath, { ...options, tools: ["data-harness-cli"] });
     localTools = await installLocalTools(runtimeDir, options);
   }
+  ok(`${Object.keys(manifest.installedTools || {}).length + Object.keys(localTools).length} 个 CLI 已安装到 bin/`);
+  blank();
 
+  step(4, 8, "同步 Wikis 知识库");
   await installWikis(runtimeDir, options);
+  blank();
+
+  step(5, 8, "生成本地配置");
   writeLocalConfig(runtimeDir, { overwrite: true });
+  ok("config/harness-config.yaml");
+  ok("config/qdm-cli-paths.env");
+  blank();
+
+  step(6, 8, "配置 CAS 认证");
   const casDir = await writeCasCredentials(runtimeDir, options);
   await configureTokens(runtimeDir, casDir);
+  blank();
+
+  step(7, 8, "构建 Wikis 索引");
   await buildAndCheck(runtimeDir, options);
+  blank();
+
+  step(8, 8, "配置 Agent Hook");
   linkAgents(runtimeDir, await chooseAgent(options));
+  for (const [target, source] of [[".claude", "agents/claude"], [".codex", "agents/codex"], [".pi", "agents/pi"]]) {
+    if (fs.existsSync(path.join(runtimeDir, target))) ok(`${target} -> ${source}`);
+  }
+  blank();
 
+  console.log("安装校验");
   const doctor = await collectDoctor(runtimeDir, { ...options, casConfigDir: casDir });
-  for (const check of doctor.checks) console.log(`${check.ok ? "PASS" : "FAIL"} ${check.name}`);
+  printDoctorSummary(doctor);
   if (doctor.checks.some((check) => !check.ok)) throw new Error("doctor failed; install is incomplete");
+  blank();
 
   writeState(runtimeDir, {
     installMode: tokenMode ? "github-token" : "local-path",
@@ -206,5 +286,8 @@ export async function installCommand(options = {}) {
     packageVersion: packageVersion(),
     lastCheckAt: new Date().toISOString()
   });
-  console.log(`Harness Data runtime installed: ${runtimeDir}`);
+  console.log(`安装完成：${runtimeDir}`);
+  console.log("");
+  console.log("下一步：");
+  console.log(`cd ${runtimeDir}`);
 }

package/src/commands/update.js

@@ -7,8 +7,9 @@ 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 { buildAndCheck, installRuntimeBundle } from "./install.js";
+import { buildAndCheck, installRuntimeBundle, printDoctorSummary } from "./install.js";
 import { collectDoctor } from "./doctor.js";
+import { action, blank, header, ok, shortSha, skip, step, warn } from "../lib/log.js";
 
 async function npmLatest() {
   try {
@@ -60,21 +61,20 @@ async function maybeUpdateTool(runtimeDir, manifest, tool, options, state) {
   const assetName = toolAssetName(tool, tag, key);
   const asset = releaseAsset(release, assetName);
   if (!asset) {
-    console.warn(`warning: ${tool.name} latest release has no ${assetName}; skipped`);
+    warn(`${tool.name} 最新 release 缺少 ${assetName}，已跳过`);
     return null;
   }
   const current = state.tools?.[tool.name] || {};
   const tagChanged = current.version && current.version !== tag;
   const firstInstall = !current.version;
   if (!tagChanged && !firstInstall) {
-    console.log(`${tool.name}: up to date (${tag})`);
+    ok(`${tool.name} 已是最新 ${tag}`);
     return null;
   }
-  console.log(`${tool.name} has update:`);
-  console.log(`  current: ${current.version || "unknown"}`);
-  console.log(`  remote:  ${tag}`);
-  if (!(await confirm(`Update ${tool.name}?`, { defaultNo: true }))) {
-    console.log(`Skipped ${tool.name}`);
+  action(`发现更新：${tool.name} ${current.version || "unknown"} -> ${tag}`);
+  if (!(await confirm(`是否更新 ${tool.name}？`, { defaultNo: true }))) {
+    skip(tool.name);
+    options.skippedUpdates?.push(`${tool.name} ${tag}`);
     return null;
   }
   const updatedManifest = oneToolManifest(manifest, tool, tag, asset, key);
@@ -82,35 +82,38 @@ async function maybeUpdateTool(runtimeDir, manifest, tool, options, state) {
     ...options,
     manifestOverride: updatedManifest
   });
-  return installed.installedTools?.[tool.name] || { version: tag, asset: assetName };
+  const result = installed.installedTools?.[tool.name] || { version: tag, asset: assetName };
+  ok(`${tool.name} 已更新到 ${tag}`);
+  return result;
 }
 
 async function updateWikis(runtimeDir, options, state) {
   const wikisDir = path.join(runtimeDir, "wikis");
   if (!githubToken(options) && state.installMode !== "github-token") {
-    console.log("wikis: local path mode; check manually");
+    skip("harness-data-wikis 为本地路径模式，请手动检查");
     return null;
   }
   if (!fs.existsSync(path.join(wikisDir, ".git"))) {
-    console.log("wikis: not a git checkout; skipped");
+    skip("harness-data-wikis 不是 git checkout");
     return null;
   }
-  await run("git", ["-C", wikisDir, "fetch", "origin"], { stdio: "inherit" });
+  await run("git", ["-C", wikisDir, "fetch", "origin"]);
   const local = (await run("git", ["-C", wikisDir, "rev-parse", "HEAD"])).stdout.trim();
   const remote = (await run("git", ["-C", wikisDir, "rev-parse", "origin/HEAD"], { allowFailure: true })).stdout.trim();
   if (!remote || local === remote) {
-    console.log(`wikis: up to date (${local.slice(0, 12)})`);
+    ok(`harness-data-wikis 已是最新 ${shortSha(local)}`);
     return null;
   }
-  console.log("wikis has update:");
-  console.log(`  current: ${local}`);
-  console.log(`  remote:  ${remote}`);
-  if (!(await confirm("Update wikis?", { defaultNo: true }))) {
-    console.log("Skipped wikis");
+  action(`发现更新：harness-data-wikis ${shortSha(local)} -> ${shortSha(remote)}`);
+  if (!(await confirm("是否更新 harness-data-wikis？", { defaultNo: true }))) {
+    skip("harness-data-wikis");
+    options.skippedUpdates?.push(`harness-data-wikis ${shortSha(remote)}`);
     return null;
   }
-  await run("git", ["-C", wikisDir, "pull", "--ff-only"], { stdio: "inherit" });
-  return { commit: (await run("git", ["-C", wikisDir, "rev-parse", "HEAD"])).stdout.trim() };
+  await run("git", ["-C", wikisDir, "pull", "--ff-only"]);
+  const commit = (await run("git", ["-C", wikisDir, "rev-parse", "HEAD"])).stdout.trim();
+  ok(`harness-data-wikis 已更新到 ${shortSha(commit)}`);
+  return { commit };
 }
 
 export async function checkUpdates(workspace, options = {}) {
@@ -126,54 +129,85 @@ export async function checkUpdates(workspace, options = {}) {
 export async function updateCommand(options = {}) {
   const runtimeDir = findWorkspaceDir(options.dir);
   if (!fs.existsSync(runtimeDir)) throw new Error(`runtime directory does not exist: ${runtimeDir}`);
+  const key = platformKey();
+  header("Harness Data 更新器", packageVersion(), [
+    `运行目录：${runtimeDir}`,
+    `平台：${key}`
+  ]);
   const state = readUserState();
   const manifestPath = path.join(runtimeDir, "bootstrap", "cli-manifest.json");
   const manifest = readManifest(manifestPath);
   let changed = false;
   let runtimeTag = state.runtimeTag || "";
   const nextTools = { ...(state.tools || {}) };
+  const applied = [];
+  const skipped = [];
+  const trackingOptions = { ...options, skippedUpdates: skipped };
 
+  step(1, 6, "检查 installer");
   const latestInstaller = await npmLatest();
   if (latestInstaller && latestInstaller !== packageVersion()) {
-    console.log(`installer has update: ${packageVersion()} -> ${latestInstaller}`);
-    console.log("Run the same npx command again to use the latest npm installer.");
+    warn(`installer 有新版本 ${packageVersion()} -> ${latestInstaller}`);
+    action("请重新执行：npx @lumi-ai-lab/harness-data@latest update");
   } else {
-    console.log(`installer: up to date (${packageVersion()})`);
+    ok(`installer 已是最新 ${packageVersion()}`);
   }
+  blank();
 
+  step(2, 6, "检查 runtime bundle");
   const runtimeRelease = await latestRelease("lumi-ai-lab/harness-data", options);
   if (state.runtimeTag && state.runtimeTag !== runtimeRelease.tag_name) {
-    console.log(`runtime bundle has update: ${state.runtimeTag} -> ${runtimeRelease.tag_name}`);
-    if (await confirm("Update runtime bundle?", { defaultNo: true })) {
-      const bundle = await installRuntimeBundle(runtimeDir, { ...options, force: true });
+    action(`发现更新：runtime bundle ${state.runtimeTag} -> ${runtimeRelease.tag_name}`);
+    if (await confirm("是否更新 runtime bundle？", { defaultNo: true })) {
+      const bundle = await installRuntimeBundle(runtimeDir, { ...trackingOptions, force: true });
       runtimeTag = bundle.tag || runtimeRelease.tag_name;
       changed = true;
+      applied.push(`runtime bundle ${runtimeTag}`);
     } else {
-      console.log("Skipped runtime bundle");
+      skip("runtime bundle");
+      skipped.push(`runtime bundle ${runtimeRelease.tag_name}`);
     }
   } else {
-    console.log(`runtime bundle: up to date (${state.runtimeTag || runtimeRelease.tag_name})`);
+    ok(`runtime bundle 已是最新 ${state.runtimeTag || runtimeRelease.tag_name}`);
   }
+  blank();
 
+  step(3, 6, "检查 CLI 工具");
   for (const tool of manifest.tools || []) {
     if (state.installMode === "local-path" && tool.name !== "data-harness-cli") {
-      console.log(`${tool.name}: local path mode; check manually`);
+      skip(`${tool.name} 为本地路径模式，请手动检查`);
       continue;
     }
-    const installed = await maybeUpdateTool(runtimeDir, manifest, tool, options, state);
+    const installed = await maybeUpdateTool(runtimeDir, manifest, tool, trackingOptions, state);
     if (installed) {
       nextTools[tool.name] = installed;
       changed = true;
+      applied.push(`${tool.name} ${installed.version || ""}`.trim());
     }
   }
+  blank();
 
-  const wikis = await updateWikis(runtimeDir, options, state);
-  if (wikis) changed = true;
+  step(4, 6, "检查 Wikis 知识库");
+  const wikis = await updateWikis(runtimeDir, trackingOptions, state);
+  if (wikis) {
+    changed = true;
+    applied.push(`harness-data-wikis ${shortSha(wikis.commit)}`);
+  }
+  blank();
 
+  step(5, 6, "构建 Wikis 索引");
   if (changed) {
-    await buildAndCheck(runtimeDir, options);
-    const doctor = await collectDoctor(runtimeDir, options);
-    for (const check of doctor.checks) console.log(`${check.ok ? "PASS" : "FAIL"} ${check.name}${check.detail ? ` (${check.detail})` : ""}`);
+    await buildAndCheck(runtimeDir, trackingOptions);
+  } else {
+    skip("没有组件更新");
+  }
+  blank();
+
+  step(6, 6, "安装校验");
+  if (changed) {
+    const doctor = await collectDoctor(runtimeDir, trackingOptions);
+    printDoctorSummary(doctor);
+    if (doctor.checks.some((check) => !check.ok)) throw new Error("doctor failed; update is incomplete");
     writeState(runtimeDir, {
       ...state,
       runtimeTag,
@@ -181,9 +215,27 @@ export async function updateCommand(options = {}) {
       manifestSha256: manifestDigest(manifest),
       lastCheckAt: new Date().toISOString()
     });
-    console.log("Harness Data runtime updated.");
+    blank();
+    console.log(`更新完成：${runtimeDir}`);
+    if (applied.length) {
+      console.log("");
+      console.log("已更新：");
+      for (const item of applied) console.log(`- ${item}`);
+    }
+    if (skipped.length) {
+      console.log("");
+      console.log("已跳过：");
+      for (const item of skipped) console.log(`- ${item}`);
+    }
   } else {
+    skip("没有组件更新");
     writeState(runtimeDir, { ...state, lastCheckAt: new Date().toISOString() });
-    console.log("No selected updates were applied.");
+    blank();
+    console.log(skipped.length ? "没有应用任何更新。" : "没有发现需要更新的内容。");
+    if (skipped.length) {
+      console.log("");
+      console.log("已跳过：");
+      for (const item of skipped) console.log(`- ${item}`);
+    }
   }
 }

package/src/lib/exec.js

@@ -4,7 +4,7 @@ export function run(command, args = [], options = {}) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       cwd: options.cwd,
-      env: { ...process.env, ...(options.env || {}) },
+      env: { ...process.env, GH_NO_UPDATE_NOTIFIER: "1", ...(options.env || {}) },
       shell: options.shell || false,
       stdio: options.stdio || "pipe"
     });

package/src/lib/log.js

@@ -0,0 +1,39 @@
+export function header(title, version, rows = []) {
+  console.log(`${title} ${version}`);
+  console.log("");
+  for (const row of rows) console.log(row);
+  if (rows.length) console.log("");
+}
+
+export function step(index, total, title) {
+  console.log(`[${index}/${total}] ${title}`);
+}
+
+export function ok(message) {
+  console.log(`通过：${message}`);
+}
+
+export function warn(message) {
+  console.warn(`提示：${message}`);
+}
+
+export function skip(message) {
+  console.log(`跳过：${message}`);
+}
+
+export function fail(message) {
+  console.log(`失败：${message}`);
+}
+
+export function action(message) {
+  console.log(message);
+}
+
+export function blank() {
+  console.log("");
+}
+
+export function shortSha(value) {
+  return value ? value.slice(0, 7) : "";
+}
+

package/src/lib/manifest.js

@@ -4,6 +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";
 
 export function readManifest(file) {
   return JSON.parse(fs.readFileSync(file, "utf8"));
@@ -115,7 +116,6 @@ async function downloadAsset(tool, asset, file, options = {}) {
     await download(asset.url, file);
     return;
   }
-  console.log(`Downloading private ${tool.name} asset from ${tool.repo}`);
   if (await downloadPrivateWithGh(asset, file)) return;
   if (await downloadPrivateWithToken(asset, file, options)) return;
   throw new Error(`private GitHub Release asset requires gh auth login, GITHUB_TOKEN, or --github-token: ${assetName(asset)}`);
@@ -151,16 +151,16 @@ export async function installToolsFromManifest(workspace, manifestPath, options
     const asset = tool.platforms?.[key];
     if (!asset?.url) throw new Error(`manifest missing ${tool.name} asset for ${key}`);
     const archive = path.join(cacheDir, assetName(asset));
-    console.log(`Downloading ${tool.name} ${tool.version} (${key})`);
+    if (options.log !== false) action(`下载 ${tool.name} ${tool.version} (${key})`);
     await downloadAsset(tool, asset, archive, options);
     const sha = await expectedSha256(tool, asset, options);
     const actualSha = fileSha256(archive);
     if (sha && actualSha !== sha) throw new Error(`${tool.name} sha256 mismatch`);
-    if (!sha) console.warn(`warning: ${tool.name} has no sha256; continuing without checksum`);
+    if (!sha) warn(`${tool.name} 未提供 sha256，已继续安装`);
     if (archive.endsWith(".zip")) {
-      await run("unzip", ["-o", archive, "-d", binDir], { stdio: "inherit" });
+      await run("unzip", ["-o", archive, "-d", binDir]);
     } else {
-      await run("tar", ["-xzf", archive, "-C", binDir], { stdio: "inherit" });
+      await run("tar", ["-xzf", archive, "-C", binDir]);
     }
     const binary = path.join(binDir, tool.binary);
     if (!fs.existsSync(binary)) throw new Error(`${tool.binary} was not extracted to bin/`);

package/src/lib/prompt.js

@@ -26,7 +26,7 @@ export async function chooseAgent(options = {}) {
   if (options.yes) return "all";
   const rl = readline.createInterface({ input, output });
   try {
-    const answer = (await rl.question("Choose Agent: claude, codex, pi, all [all] ")).trim().toLowerCase();
+    const answer = (await rl.question("选择 Agent：claude, codex, pi, all [all] ")).trim().toLowerCase();
     const value = answer || "all";
     if (!agentChoices.includes(value)) throw new Error("agent must be claude, codex, pi, or all");
     return value;