@pab-iprg/huohuo 1.0.0-preview.2 → 1.0.0-preview.4

package/README.md

@@ -6,7 +6,11 @@
 
 发布后的预览入口为 `npx --yes @pab-iprg/huohuo@next`。首版验收基线为 macOS Apple Silicon、Node 24.8.0 和 npm 11.6.0。默认持久目录为 `~/.huohuo`，普通重开保留已安装版本，安装中断后继续原目标。
 
-命令支持 `huohuo [start|doctor|stop|upgrade|uninstall] [--home 目录] [--no-open]`。
+安装前会列出磁盘预留量、内存要求、固定下载项和缓存位置。输入 `y` 继续，直接回车取消。自动化环境可用 `npx --yes @pab-iprg/huohuo@next --yes` 显式同意安装。固定资源显示实际接收量，下载失败可重跑并复用已经校验的文件。
+
+发行清单可为同一份固定资源配置备用 HTTPS 地址。确认安装后会探测这些地址，优先从响应较快的可用地址下载，并核对同一个 SHA-256。只有一个已核验来源时，网络中断会自动重试一次。npm 和 pip 仍会按各自的依赖清单安装。
+
+命令支持 `huohuo [start|status|doctor|stop|upgrade|uninstall] [--home 目录] [--no-open]`。在另一个终端运行 `npx --yes @pab-iprg/huohuo@next status --watch` 可打开实时状态看板，按 Ctrl+C 退出看板。
 
 显式升级检查旧迁移不可变、追加迁移顺序、执行库格式与 DSH 会话兼容范围，先一致性备份再迁移和验证，成功后切换；不自动恢复旧备份覆盖新数据。默认卸载保留实例、凭据、会话和备份，不提供直接彻底删除业务数据的快捷入口。
 

package/cli.js

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 
 // distribution/bootstrap/entry.ts
-import { readFile as readFile7, realpath as realpath5 } from "node:fs/promises";
-import { createReadStream as createReadStream2 } from "node:fs";
+import { open as open3, readFile as readFile8, realpath as realpath5 } from "node:fs/promises";
 import { Readable } from "node:stream";
 import { homedir } from "node:os";
-import { dirname as dirname5, join as join6, resolve as resolve5 } from "node:path";
+import { dirname as dirname5, join as join7, resolve as resolve5 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // distribution/bootstrap/install.ts
@@ -133,20 +132,24 @@ var hash = /^[a-f0-9]{64}$/;
 function integer(n) {
   return Number.isSafeInteger(n) && Number(n) >= 0;
 }
-function artifact(a) {
-  if (!a || !hash.test(a.sha256) || !integer(a.downloadBytes) || !integer(a.expandedBytes) || !a.downloadBytes || !a.expandedBytes) return false;
-  if (a.redirectHosts !== void 0 && (!Array.isArray(a.redirectHosts) || a.redirectHosts.length > 4 || !a.redirectHosts.every((s) => typeof s === "string" && /^[a-z0-9.-]+$/.test(s)))) return false;
-  if (a.bundled !== void 0) return a.bundled === true && a.url === `https://bundled.invalid/${a.sha256}.tgz` && a.redirectHosts === void 0;
+function httpsURL(value) {
+  if (typeof value !== "string") return false;
   try {
-    const u = new URL(a.url);
+    const u = new URL(value);
     return u.protocol === "https:" && !u.username && !u.password && !u.hash;
   } catch {
     return false;
   }
 }
+function artifact(a) {
+  if (!a || !hash.test(a.sha256) || !integer(a.downloadBytes) || !integer(a.expandedBytes) || !a.downloadBytes || !a.expandedBytes) return false;
+  if (a.redirectHosts !== void 0 && (!Array.isArray(a.redirectHosts) || a.redirectHosts.length > 4 || !a.redirectHosts.every((s) => typeof s === "string" && /^[a-z0-9.-]+$/.test(s)))) return false;
+  if (a.bundled !== void 0) return a.bundled === true && a.url === `https://bundled.invalid/${a.sha256}.tgz` && a.redirectHosts === void 0 && a.mirrors === void 0;
+  return httpsURL(a.url) && (a.mirrors === void 0 || Array.isArray(a.mirrors) && a.mirrors.length <= 3 && a.mirrors.every(httpsURL));
+}
 function validateRelease(input) {
   const r = input;
-  if (!r || r.format !== 1 || r.bootstrapFormat !== 1 || !version.test(r.version) || !integer(r.nodeMajor) || r.nodeMajor < 24 || !integer(r.npmMajor) || r.npmMajor < 11 || !r.platform?.minimumOsRelease || !["darwin", "linux", "win32"].includes(r.platform.os) || !["arm64", "x64"].includes(r.platform.arch) || !artifact(r.runtime) || r.runtime.name !== "@huohuo/research-agent" || r.runtime.version !== r.version || !/^sha512-[A-Za-z0-9+/]+={0,2}$/.test(r.runtime.integrity) || !artifact(r.python) || !artifact(r.pythonDependencies) || !r.python.build || !r.python.license || !r.python.executable || r.python.executable.startsWith("/") || r.python.executable.split(/[\\/]/).some((p) => p === ".." || !p) || !version.test(r.dsh?.version) || !hash.test(r.dsh?.assemblySha256) || !hash.test(r.requirementsSha256) || !hash.test(r.profilesSha256) || !r.budget || ![
+  if (!r || r.format !== 1 || r.bootstrapFormat !== 1 || !version.test(r.version) || !integer(r.nodeMajor) || r.nodeMajor < 24 || !integer(r.npmMajor) || r.npmMajor < 11 || !r.platform?.minimumOsRelease || !["darwin", "linux", "win32"].includes(r.platform.os) || !["arm64", "x64"].includes(r.platform.arch) || !artifact(r.runtime) || r.runtime.name !== "@huohuo/research-agent" || r.runtime.version !== r.version || !/^sha512-[A-Za-z0-9+/]+={0,2}$/.test(r.runtime.integrity) || !artifact(r.python) || !artifact(r.pythonDependencies) || !r.python.build || !r.python.license || r.pythonDependencies.upstreamWheelCount !== void 0 && !integer(r.pythonDependencies.upstreamWheelCount) || !r.python.executable || r.python.executable.startsWith("/") || r.python.executable.split(/[\\/]/).some((p) => p === ".." || !p) || !version.test(r.dsh?.version) || !hash.test(r.dsh?.assemblySha256) || !hash.test(r.requirementsSha256) || !hash.test(r.profilesSha256) || !r.budget || ![
     "minimumEffectiveMemoryBytes",
     "startupHeadroomBytes",
     "heavyJobHeadroomBytes",
@@ -158,7 +161,7 @@ function validateRelease(input) {
     "processTreeBudgetBytes",
     "sampleIntervalMs",
     "sampleMaxAgeMs"
-  ].every((k) => integer(r.budget[k])) || r.budget.startupHeadroomBytes <= 0 || r.budget.minimumEffectiveMemoryBytes <= 0 || r.budget.diskReserveBytes <= 0 || r.budget.recoverySamples < 2 || r.budget.heavyJobHeadroomBytes < r.budget.startupHeadroomBytes || r.budget.processTreeBudgetBytes <= 0 || r.budget.sampleIntervalMs < 1e3 || r.budget.sampleMaxAgeMs < r.budget.sampleIntervalMs * 2 || r.budget.sampleMaxAgeMs > 3e4 || !r.schema || !integer(r.schema.minimum) || !integer(r.schema.maximum) || r.schema.minimum > r.schema.maximum) {
+  ].every((k) => integer(r.budget[k])) || r.budget.observedInstallRssBytes !== void 0 && (!integer(r.budget.observedInstallRssBytes) || r.budget.observedInstallRssBytes <= 0) || r.budget.startupHeadroomBytes <= 0 || r.budget.minimumEffectiveMemoryBytes <= 0 || r.budget.diskReserveBytes <= 0 || r.budget.recoverySamples < 2 || r.budget.heavyJobHeadroomBytes < r.budget.startupHeadroomBytes || r.budget.processTreeBudgetBytes <= 0 || r.budget.sampleIntervalMs < 1e3 || r.budget.sampleMaxAgeMs < r.budget.sampleIntervalMs * 2 || r.budget.sampleMaxAgeMs > 3e4 || !r.schema || !integer(r.schema.minimum) || !integer(r.schema.maximum) || r.schema.minimum > r.schema.maximum) {
     throw new Error("\u53D1\u884C\u6E05\u5355\u65E0\u6548\u6216\u5C1A\u672A\u5B8C\u6210\u5E73\u53F0\u3001\u6458\u8981\u4E0E\u8D44\u6E90\u6D4B\u91CF\uFF1B\u4E0D\u80FD\u5B89\u88C5");
   }
   if (!hash.test(r.schema.migrationsSha256)) throw new Error("\u7F3A\u5C11\u6570\u636E\u5E93\u8FC1\u79FB\u88C5\u914D\u6458\u8981");
@@ -182,45 +185,102 @@ async function verifyArtifact(path, artifact2) {
   }
   if (bytes !== artifact2.downloadBytes || digest2.digest("hex") !== artifact2.sha256 || "integrity" in artifact2 && artifact2.integrity !== `sha512-${integrity.digest("base64")}`) throw new Error("\u4E0B\u8F7D\u4EA7\u7269\u5927\u5C0F\u6216\u6458\u8981\u4E0D\u7B26");
 }
-async function downloadArtifact(artifact2, path, fetcher = fetch) {
+var RetryableDownload = class extends Error {
+};
+async function downloadArtifact(artifact2, path, fetcher = fetch, progress) {
   try {
     await verifyArtifact(path, artifact2);
+    progress?.({ status: "cached", bytes: artifact2.downloadBytes });
     return;
   } catch (e) {
     if (e.code !== "ENOENT") throw e;
   }
   await mkdir2(dirname2(path), { recursive: true, mode: 448 });
+  const sources = [.../* @__PURE__ */ new Set([artifact2.url, ...artifact2.mirrors ?? []])];
+  if (sources.length > 1) {
+    progress?.({ status: "probing", bytes: 0 });
+    const results = await Promise.all(sources.map(async (source) => {
+      const started = performance.now();
+      try {
+        const response = await requestSource(artifact2, source, fetcher, AbortSignal.timeout(5e3), "HEAD");
+        await response.body?.cancel();
+        return { source, latency: response.ok ? performance.now() - started : Infinity };
+      } catch {
+        return { source, latency: Infinity };
+      }
+    }));
+    results.sort((a, b) => a.latency - b.latency);
+    sources.splice(0, sources.length, ...results.map((result) => result.source));
+  } else if (!artifact2.bundled) sources.push(artifact2.url);
+  for (const [index, source] of sources.entries()) {
+    const host = artifact2.bundled ? void 0 : new URL(source).hostname;
+    progress?.({ status: "start", bytes: 0, host });
+    try {
+      await transfer(artifact2, path, source, fetcher, (bytes) => progress?.({ status: "receiving", bytes, host }));
+      progress?.({ status: "verified", bytes: artifact2.downloadBytes, host });
+      return;
+    } catch (error) {
+      if (!(error instanceof RetryableDownload)) throw error;
+      if (index === sources.length - 1) throw new Error(`${host} \u4E0B\u8F7D\u672A\u5B8C\u6210\uFF08${error.message}\uFF09\u3002\u8BF7\u68C0\u67E5\u7F51\u7EDC\u540E\u91CD\u8DD1\uFF0C\u5DF2\u6821\u9A8C\u7684\u6587\u4EF6\u4F1A\u590D\u7528\u3002`, { cause: error });
+      progress?.({ status: "retry", bytes: 0, host });
+    }
+  }
+}
+async function requestSource(artifact2, source, fetcher, signal, method, onResponse) {
+  const allowed = /* @__PURE__ */ new Set([new URL(source).hostname, ...artifact2.redirectHosts ?? []]);
+  let url = source;
+  for (let redirects = 0; redirects <= 4; redirects++) {
+    const next = new URL(url);
+    if (next.protocol !== "https:" || next.username || next.password || !allowed.has(next.hostname)) throw new Error("\u4E0B\u8F7D\u91CD\u5B9A\u5411\u4E0D\u5728\u56FA\u5B9A\u53D1\u884C\u5141\u8BB8\u6765\u6E90\u5185");
+    const response = await fetcher(url, { signal, method, redirect: "manual" });
+    onResponse?.();
+    if (![301, 302, 303, 307, 308].includes(response.status)) return response;
+    const location = response.headers.get("location");
+    await response.body?.cancel();
+    if (!location || redirects === 4) throw new Error("\u4E0B\u8F7D\u91CD\u5B9A\u5411\u65E0\u6548\u6216\u8FC7\u591A");
+    url = new URL(location, url).href;
+  }
+  throw new Error("\u4E0B\u8F7D\u672A\u8FD4\u56DE\u54CD\u5E94");
+}
+async function transfer(artifact2, path, source, fetcher, onBytes) {
   const pending = `${path}.${randomUUID2()}.partial`;
   const handle = await open2(pending, "wx", 384);
+  const idle = new AbortController();
+  let timer;
+  const keepAlive = () => {
+    clearTimeout(timer);
+    timer = setTimeout(() => idle.abort(), 45e3);
+    timer.unref();
+  };
+  const signal = AbortSignal.any([idle.signal, AbortSignal.timeout(30 * 6e4)]);
+  keepAlive();
   try {
-    const allowed = /* @__PURE__ */ new Set([new URL(artifact2.url).hostname, ...artifact2.redirectHosts ?? []]);
-    let url = artifact2.url;
-    let response;
-    const transferMs = Math.ceil(artifact2.downloadBytes / (64 * 1024)) * 1e3;
-    const signal = AbortSignal.timeout(Math.min(9e5, Math.max(12e4, 3e4 + transferMs)));
-    for (let redirects = 0; redirects <= 4; redirects++) {
-      const next = new URL(url);
-      if (next.protocol !== "https:" || next.username || next.password || !allowed.has(next.hostname)) throw new Error("\u4E0B\u8F7D\u91CD\u5B9A\u5411\u4E0D\u5728\u56FA\u5B9A\u53D1\u884C\u5141\u8BB8\u6765\u6E90\u5185");
-      response = await fetcher(url, { signal, redirect: "manual" });
-      if (![301, 302, 303, 307, 308].includes(response.status)) break;
-      const location = response.headers.get("location");
+    const response = await requestSource(artifact2, source, fetcher, signal, "GET", keepAlive);
+    if (!response.ok || !response.body) {
       await response.body?.cancel();
-      if (!location || redirects === 4) throw new Error("\u4E0B\u8F7D\u91CD\u5B9A\u5411\u65E0\u6548\u6216\u8FC7\u591A");
-      url = new URL(location, url).href;
+      if (!artifact2.bundled && (response.status === 408 || response.status === 429 || response.status >= 500 || artifact2.mirrors?.length && [403, 404].includes(response.status))) {
+        throw new RetryableDownload(`HTTP ${response.status}`);
+      }
+      throw new Error(`\u4E0B\u8F7D\u5931\u8D25\uFF1AHTTP ${response.status}`);
     }
-    if (!response) throw new Error("\u4E0B\u8F7D\u672A\u8FD4\u56DE\u54CD\u5E94");
-    if (!response.ok || !response.body) throw new Error(`\u4E0B\u8F7D\u5931\u8D25\uFF1AHTTP ${response.status}`);
     let received = 0;
     for await (const chunk of response.body) {
       received += chunk.byteLength;
+      keepAlive();
       if (received > artifact2.downloadBytes) throw new Error("\u4E0B\u8F7D\u8D85\u8FC7\u53D1\u884C\u6E05\u5355\u5927\u5C0F");
       await handle.writeFile(chunk);
+      onBytes(received);
     }
     await handle.sync();
     await handle.close();
     await verifyArtifact(pending, artifact2);
     await rename2(pending, path);
+  } catch (error) {
+    if (!artifact2.bundled && signal.aborted) throw new RetryableDownload(idle.signal.aborted ? "\u8FDE\u7EED 45 \u79D2\u672A\u6536\u5230\u6570\u636E" : "\u8D85\u8FC7\u5355\u6B21\u4E0B\u8F7D\u65F6\u9650", { cause: error });
+    if (!artifact2.bundled && error instanceof TypeError) throw new RetryableDownload("\u7F51\u7EDC\u8FDE\u63A5\u4E2D\u65AD", { cause: error });
+    throw error;
   } finally {
+    clearTimeout(timer);
     await handle.close().catch(() => {
     });
     await rm(pending, { force: true });
@@ -588,6 +648,32 @@ async function install(home, candidate, hooks = {}, programsOnly = false) {
     if (!programsOnly && !record && (await readdir(home)).some((name) => name !== "state")) throw new Error("\u76EE\u5F55\u542B\u65E0\u5B89\u88C5\u8BB0\u5F55\u7684\u65E2\u6709\u5185\u5BB9\uFF1B\u8BF7\u6838\u67E5\u5F52\u5C5E\u6216\u9009\u62E9\u7A7A\u76EE\u5F55");
     if (!programsOnly && !record && (await readdir(join3(home, "state"))).some((name) => name !== "install.lock")) throw new Error("\u76EE\u5F55\u542B\u65E0\u6CD5\u786E\u8BA4\u5F52\u5C5E\u7684\u72B6\u6001\uFF1B\u672A\u91CD\u5EFA\u5B89\u88C5");
     if (programsOnly && (await readInstallation(home))?.status !== "ready") throw new Error("\u5F53\u524D\u5B89\u88C5\u4E0D\u5B8C\u6574\uFF0C\u5148\u4FEE\u590D\u539F\u7248\u672C");
+    const bundleDirectory = hooks.bundleDirectory;
+    if (!programsOnly && record && bundleDirectory && candidate && ["installing", "blocked", "failed"].includes(record.status) && ["preflight", "download"].includes(record.stage) && Object.keys(record.stages).every((stage2) => stage2 === "preflight" || stage2 === "download")) {
+      const hasFile = async (path) => {
+        try {
+          await access(path);
+          return true;
+        } catch (error) {
+          if (error.code === "ENOENT") return false;
+          throw error;
+        }
+      };
+      const bundled = (release2) => [release2.runtime, release2.python, release2.pythonDependencies].filter((artifact2) => artifact2.bundled);
+      const oldAssets = bundled(record.release);
+      const available = await Promise.all(oldAssets.map(async (artifact2) => {
+        const file = artifact2.sha256 + ".tgz";
+        return await hasFile(join3(bundleDirectory, file)) || await hasFile(join3(home, "cache", file));
+      }));
+      if (available.includes(false)) {
+        const next = validateRelease(candidate);
+        const nextAssets = bundled(next);
+        if (next.runtime.bundled && next.version === record.release.version && (await Promise.all(nextAssets.map((artifact2) => hasFile(join3(bundleDirectory, artifact2.sha256 + ".tgz"))))).every(Boolean)) {
+          record = void 0;
+          hooks.progress?.("resume-current-package");
+        }
+      }
+    }
     const release = record?.release ?? validateRelease(candidate);
     if (release.platform.os !== process.platform || release.platform.arch !== process.arch || !versionAtLeast(osRelease(), release.platform.minimumOsRelease) || !versionAtLeast(process.versions.node, "24.8.0") || Number(process.versions.node.split(".")[0]) !== release.nodeMajor) {
       throw new Error("\u6B64\u53D1\u884C\u5C1A\u672A\u9A8C\u8BC1\u5F53\u524D OS/CPU/Node \u7EC4\u5408\uFF1B\u672A\u5F00\u59CB\u91CD\u4E0B\u8F7D");
@@ -597,6 +683,20 @@ async function install(home, candidate, hooks = {}, programsOnly = false) {
     const paths = installationPaths(home, release);
     const execute4 = hooks.run ?? run;
     const sample = hooks.sample ?? sampleResources;
+    const files = [
+      { name: "\u706B\u706B\u8FD0\u884C\u5305", artifact: release.runtime, path: paths.archive },
+      { name: "Python \u8FD0\u884C\u73AF\u5883", artifact: release.python, path: paths.pythonArchive },
+      { name: "Python \u4F9D\u8D56\u6E05\u5355\u6216\u79BB\u7EBF\u5305", artifact: release.pythonDependencies, path: join3(home, "cache", release.pythonDependencies.sha256 + ".tgz") }
+    ];
+    const withActivity = async (label, action) => {
+      hooks.progress?.(label);
+      const timer = hooks.progress && setInterval(() => hooks.progress?.(`${label}\u4ECD\u5728\u8FDB\u884C\uFF0C\u8BF7\u7A0D\u5019`), 2e4);
+      try {
+        await action();
+      } finally {
+        if (timer) clearInterval(timer);
+      }
+    };
     const cached = async (path, artifact2) => {
       try {
         await verifyArtifact(path, artifact2);
@@ -631,15 +731,10 @@ async function install(home, candidate, hooks = {}, programsOnly = false) {
       }
     };
     const check = async () => {
-      const [runtimeCached, pythonCached, wheelsCached, inventory] = await Promise.all([
-        cached(paths.archive, release.runtime),
-        cached(paths.pythonArchive, release.python),
-        cached(join3(home, "cache", release.pythonDependencies.sha256 + ".tgz"), release.pythonDependencies),
-        installed()
-      ]);
+      const [cacheHits, inventory] = await Promise.all([Promise.all(files.map((file) => cached(file.path, file.artifact))), installed()]);
       const remainingDependencies = inventory.dependencies ? 0 : release.budget.dependenciesBytes;
       const costs = [
-        { path: join3(home, "cache"), bytes: (runtimeCached ? 0 : release.runtime.downloadBytes) + (pythonCached ? 0 : release.python.downloadBytes) + (wheelsCached ? 0 : release.pythonDependencies.downloadBytes) },
+        { path: join3(home, "cache"), bytes: files.reduce((sum, file, index) => sum + (cacheHits[index] ? 0 : file.artifact.downloadBytes), 0) },
         { path: paths.directory, bytes: inventory.dependencies ? 0 : release.runtime.expandedBytes + release.budget.installTemporaryBytes },
         { path: paths.python, bytes: inventory.python ? 0 : release.python.expandedBytes },
         { path: paths.environment, bytes: 0 },
@@ -665,6 +760,19 @@ async function install(home, candidate, hooks = {}, programsOnly = false) {
 ${details}
 \u5904\u7406\u540E\uFF0C\u91CD\u65B0\u8FD0\u884C\u521A\u624D\u7684\u5B89\u88C5\u547D\u4EE4\u3002`), { code: "RESOURCE_BLOCKED" });
       }
+      const pendingFiles = files.filter((_, index) => !cacheHits[index]);
+      return {
+        home,
+        resources: result,
+        cached: files.length - pendingFiles.length,
+        bundled: pendingFiles.filter((file) => file.artifact.bundled).length,
+        upstreamWheelCount: inventory.dependencies ? void 0 : release.pythonDependencies.upstreamWheelCount,
+        downloads: pendingFiles.filter((file) => !file.artifact.bundled).map((file) => ({
+          name: file.name,
+          size: file.artifact.downloadBytes,
+          host: new URL(file.artifact.url).hostname
+        }))
+      };
     };
     const stage = async (name, action) => {
       hooks.progress?.(name);
@@ -675,8 +783,8 @@ ${details}
       record.stages[name] = entry;
       await atomicJSON(recordPath, record);
       try {
-        await check();
-        const output = await action();
+        const plan = await check();
+        const output = await action(plan);
         entry.status = "verified";
         entry.outputDigest = digest(output ?? null);
         entry.endedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -684,13 +792,13 @@ ${details}
         entry.status = "failed";
         entry.endedAt = (/* @__PURE__ */ new Date()).toISOString();
         entry.errorCode = typeof error.code === "string" && /^[A-Z0-9_]+$/.test(error.code) ? error.code : "STAGE_FAILED";
-        record.status = entry.errorCode === "RESOURCE_BLOCKED" ? "blocked" : "failed";
+        record.status = entry.errorCode === "RESOURCE_BLOCKED" || entry.errorCode === "INSTALL_CANCELLED" ? "blocked" : "failed";
         await atomicJSON(recordPath, record);
         throw error;
       }
       await atomicJSON(recordPath, record);
     };
-    await stage("preflight", async () => {
+    await stage("preflight", async (plan) => {
       const npm = npmCommand();
       const { stdout } = await promisify3(execFile3)(npm.command, [...npm.prefix, "--version"], { timeout: 5e3 });
       if (!/^\d+\.\d+\.\d+\s*$/.test(stdout) || Number(stdout.split(".")[0]) !== release.npmMajor) throw new Error("npm \u7248\u672C\u672A\u77E5\u6216\u4E0D\u5728\u6B64\u53D1\u884C\u5DF2\u9A8C\u8BC1\u8303\u56F4\u5185");
@@ -700,11 +808,25 @@ ${details}
       } finally {
         await rm2(probe, { force: true });
       }
+      if (hooks.confirm && !await hooks.confirm(plan)) {
+        throw Object.assign(new Error("\u5DF2\u53D6\u6D88\u5B89\u88C5\uFF0C\u672C\u6B21\u6CA1\u6709\u8FDB\u5165\u4E0B\u8F7D\u3002"), { code: "INSTALL_CANCELLED" });
+      }
     });
     await stage("download", async () => {
-      await downloadArtifact(release.runtime, paths.archive, hooks.fetcher);
-      await downloadArtifact(release.python, paths.pythonArchive, hooks.fetcher);
-      await downloadArtifact(release.pythonDependencies, join3(home, "cache", release.pythonDependencies.sha256 + ".tgz"), hooks.fetcher);
+      for (const [index, file] of files.entries()) {
+        const progress = (event) => hooks.downloadProgress?.({
+          name: file.name,
+          index: index + 1,
+          total: files.length,
+          size: file.artifact.downloadBytes
+        }, event);
+        try {
+          await downloadArtifact(file.artifact, file.path, hooks.fetcher, progress);
+        } catch (error) {
+          progress({ status: "failed", bytes: 0 });
+          throw new Error(`${file.name}\u5904\u7406\u5931\u8D25\u3002 ${error instanceof Error ? error.message : "\u8BF7\u91CD\u8BD5\u5B89\u88C5\u3002"}`, { cause: error });
+        }
+      }
       return [release.runtime.sha256, release.python.sha256, release.pythonDependencies.sha256];
     });
     await stage("install-runtime", async () => {
@@ -737,7 +859,7 @@ ${details}
         dependencies: { "@huohuo/research-agent": `file:${paths.archive}` }
       });
       const npm = npmCommand();
-      await execute4(npm.command, [...npm.prefix, "install", "--omit=dev", "--ignore-scripts", "--no-audit", "--no-fund", "--prefer-offline", "--cache", join3(home, "cache/npm")], paths.directory);
+      await withActivity("\u5B89\u88C5 npm \u4F9D\u8D56", () => execute4(npm.command, [...npm.prefix, "install", "--omit=dev", "--ignore-scripts", "--no-audit", "--no-fund", "--prefer-offline", "--cache", join3(home, "cache/npm")], paths.directory));
       const runtime = JSON.parse(await readFile4(join3(paths.runtime, "package.json"), "utf8"));
       if (runtime.name !== release.runtime.name || runtime.version !== release.version) throw new Error("\u8FD0\u884C\u5305\u8EAB\u4EFD\u4E0D\u7B26");
       const requirements = await readFile4(join3(paths.runtime, "sidecar/requirements.lock"));
@@ -771,7 +893,12 @@ ${details}
       }
       if (!environmentReady) {
         await execute4(join3(paths.python, release.python.executable), ["-m", "venv", paths.environment], home);
-        await execute4(python, [
+        if (release.pythonDependencies.bundled && hooks.progress) {
+          const lock = await readFile4(join3(wheels, "requirements.txt"), "utf8");
+          const upstream = lock.split("\n").filter((line) => /^[\w.-]+\s+@\s+https:\/\//.test(line)).length;
+          if (upstream) hooks.progress?.(`Python \u4F9D\u8D56\u6E05\u5355\u6709 ${upstream} \u4E2A\u4E0A\u6E38\u6587\u4EF6\uFF0C\u4E0B\u65B9\u663E\u793A\u6B63\u5728\u5904\u7406\u7684\u6587\u4EF6`);
+        }
+        await withActivity("\u5B89\u88C5 Python \u4F9D\u8D56", () => execute4(python, [
           "-m",
           "pip",
           "--isolated",
@@ -784,7 +911,7 @@ ${details}
           ...release.pythonDependencies.bundled ? ["--no-cache-dir"] : [],
           "-r",
           join3(wheels, "requirements.txt")
-        ], home);
+        ], home));
       }
       await execute4(python, ["-m", "pip", "--isolated", "check"], home);
       await atomicJSON(join3(paths.environment, ".dependencies-ready.json"), { sha256: release.pythonDependencies.sha256 });
@@ -797,7 +924,7 @@ ${details}
       return record;
     }
     await stage("assemble-profiles", async () => {
-      await execute4(process.execPath, [join3(paths.runtime, "lib/distribution/managed.js"), "prepare", home], home);
+      await withActivity("\u914D\u7F6E\u5BF9\u8BDD\u4E0E\u540E\u53F0\u8FD0\u884C\u4F9D\u8D56", () => execute4(process.execPath, [join3(paths.runtime, "lib/distribution/managed.js"), "prepare", home], home));
       return { release: record.releaseDigest };
     });
     await stage("verify", async () => {
@@ -1046,18 +1173,185 @@ async function uninstall(home, hooks = {}) {
   });
 }
 
+// distribution/bootstrap/install-ui.ts
+import { createInterface } from "node:readline";
+var gb = (bytes) => bytes === null ? "\u672A\u77E5" : `${(bytes / 1e9).toFixed(2)} GB`;
+var mb = (bytes) => bytes < 1e5 ? `${(bytes / 1e3).toFixed(1)} KB` : `${(bytes / 1e6).toFixed(1)} MB`;
+function installUI(assumeYes) {
+  const interactive = process.stdin.isTTY && process.stderr.isTTY;
+  const output = process.stderr;
+  let lastUpdate = 0;
+  let lineActive = false;
+  const clear = () => {
+    if (lineActive) {
+      output.write("\r\x1B[2K");
+      lineActive = false;
+    }
+  };
+  const line = (text) => {
+    clear();
+    output.write(text + "\n");
+  };
+  return {
+    async confirm(plan) {
+      const { sample, policy, disks } = plan.resources;
+      line(`\u5B89\u88C5\u76EE\u5F55  ${plan.home}`);
+      for (const [index, disk] of disks.entries()) {
+        const location = sample.disks.find((item) => item.device === disk.device)?.paths[0] ?? plan.home;
+        line(`\u78C1\u76D8 ${index + 1}\uFF08${location}\uFF09  \u5B89\u88C5\u9884\u7559 ${gb(disk.requiredBytes)}\uFF0C\u5F53\u524D\u53EF\u7528 ${gb(disk.availableBytes)}`);
+      }
+      line(`\u5185\u5B58  \u672C\u673A\u5BB9\u91CF ${gb(sample.effectiveMemoryBytes)}\uFF0C\u5F53\u524D\u53EF\u7528 ${gb(sample.availableMemoryBytes)}`);
+      line(`\u5185\u5B58\u8981\u6C42  \u6700\u4F4E\u5BB9\u91CF ${gb(policy.minimumEffectiveMemoryBytes)}\uFF0C\u542F\u52A8\u9700\u7559\u51FA ${gb(policy.startupHeadroomBytes)}`);
+      line(policy.observedInstallRssBytes ? `\u5B89\u88C5\u5185\u5B58\u53C2\u8003  \u540C\u5E73\u53F0\u5386\u53F2\u8FDB\u7A0B\u5185\u5B58\u5CF0\u503C ${gb(policy.observedInstallRssBytes)}\uFF0C\u5B9E\u9645\u5360\u7528\u4F1A\u53D8\u5316` : "\u5B89\u88C5\u5185\u5B58\u5CF0\u503C\u968F\u4F9D\u8D56\u548C\u672C\u673A\u72B6\u6001\u53D8\u5316\uFF0C\u5F53\u524D\u6E05\u5355\u6682\u65E0\u5B9E\u6D4B\u503C");
+      for (const reason of plan.resources.reasons) line(reason);
+      const bytes = plan.downloads.reduce((total, file) => total + file.size, 0);
+      line(`\u56FA\u5B9A\u8D44\u6E90  \u8054\u7F51\u4E0B\u8F7D ${plan.downloads.length} \u9879\uFF08${mb(bytes)}\uFF09\uFF0C\u968F\u5305 ${plan.bundled} \u9879\uFF0C\u7F13\u5B58 ${plan.cached} \u9879`);
+      for (const file of plan.downloads) line(`  ${file.name}  ${mb(file.size)}  ${file.host}`);
+      line(`\u56FA\u5B9A\u8D44\u6E90\u4FDD\u5B58\u81F3  ${plan.home}/cache`);
+      if (plan.upstreamWheelCount !== void 0) line(`Python \u4F9D\u8D56\u6E05\u5355  ${plan.upstreamWheelCount} \u9879\u56FA\u5B9A\u4E0A\u6E38\u6587\u4EF6\uFF0C\u5DF2\u5B89\u88C5\u9879\u53EF\u80FD\u8DF3\u8FC7\u3002`);
+      line("\u540E\u7EED\u8FD8\u4F1A\u5B89\u88C5 npm \u548C Python \u4F9D\u8D56\uFF0C\u5B9E\u9645\u8054\u7F51\u4E0B\u8F7D\u91CF\u53D6\u51B3\u4E8E\u672C\u673A\u7F13\u5B58\u548C\u4F9D\u8D56\u89E3\u6790\u7ED3\u679C\u3002");
+      if (assumeYes) return true;
+      if (!interactive) throw new Error("\u9700\u8981\u786E\u8BA4\u5B89\u88C5\u3002\u8BF7\u5728\u7EC8\u7AEF\u8FD0\u884C\uFF0C\u6216\u5728\u706B\u706B\u547D\u4EE4\u672B\u5C3E\u52A0\u4E0A --yes\u3002");
+      const terminal = createInterface({ input: process.stdin, output, terminal: true });
+      try {
+        const answers = terminal[Symbol.asyncIterator]();
+        output.write("\u7EE7\u7EED\u5B89\u88C5\uFF1F[y/N] ");
+        const answer = await answers.next();
+        return !answer.done && /^(y|yes|是)$/i.test(answer.value.trim());
+      } finally {
+        terminal.close();
+      }
+    },
+    downloadProgress(file, event) {
+      const label = `[${file.index}/${file.total}] ${file.name}`;
+      if (event.status === "probing") {
+        line(`${label}  \u6B63\u5728\u68C0\u67E5\u4E0B\u8F7D\u6E90\u662F\u5426\u53EF\u8FBE`);
+      } else if (event.status === "start") {
+        lastUpdate = Date.now();
+        line(`${label}  ${event.host ? `\u6B63\u5728\u8FDE\u63A5 ${event.host}` : "\u6B63\u5728\u8BFB\u53D6\u968F\u5305\u8D44\u6E90"}  ${mb(file.size)}`);
+      } else if (event.status === "cached") {
+        line(`${label}  \u5DF2\u6821\u9A8C\u5E76\u590D\u7528\u7F13\u5B58`);
+      } else if (event.status === "verified") {
+        line(`${label}  \u5DF2\u5B8C\u6210\u5E76\u6821\u9A8C  ${mb(file.size)}`);
+      } else if (event.status === "retry") {
+        line(`${label}  ${event.host} \u4E0B\u8F7D\u672A\u5B8C\u6210\uFF0C\u51C6\u5907\u91CD\u8BD5`);
+      } else if (event.status === "failed") {
+        clear();
+      } else {
+        const now = Date.now();
+        if (now - lastUpdate < (interactive ? 180 : 15e3)) return;
+        lastUpdate = now;
+        const percent = Math.min(99, Math.floor(100 * event.bytes / file.size));
+        const filled = Math.floor(percent / 10);
+        const value = `[${"#".repeat(filled)}${"-".repeat(10 - filled)}] ${percent}%  ${mb(event.bytes)} / ${mb(file.size)}`;
+        if (interactive && (output.columns ?? 0) >= value.length) {
+          clear();
+          output.write(value);
+          lineActive = true;
+        } else line(`${label}  ${value}`);
+      }
+    }
+  };
+}
+
+// distribution/bootstrap/status-ui.ts
+import { readFile as readFile7 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
+var mib = (bytes) => typeof bytes === "number" && Number.isFinite(bytes) ? `${Math.round(bytes / 2 ** 20)} MiB` : "\u672A\u77E5";
+var pressureLabels = { normal: "\u6B63\u5E38", high: "\u504F\u9AD8", critical: "\u4E25\u91CD", unknown: "\u672A\u77E5" };
+async function statusLines(home) {
+  const title = "\u706B\u706B \xB7 \u8FD0\u884C\u72B6\u6001";
+  const installed = await readInstallation(home);
+  if (!installed) return [title, "\u5C1A\u672A\u5B89\u88C5\u706B\u706B\u3002"];
+  if (installed.status !== "ready") return [title, "\u5B89\u88C5\u5C1A\u672A\u5B8C\u6210\u3002"];
+  let admission;
+  try {
+    admission = JSON.parse(await readFile7(join6(home, "state/default-admission.json"), "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT") return [title, "\u6682\u65F6\u65E0\u6CD5\u8BFB\u53D6\u8D44\u6E90\u72B6\u6001\u3002"];
+  }
+  const now = Date.now() / 1e3;
+  if (!admission || admission.format !== 1 || admission.releaseDigest !== installed.releaseDigest || !Number.isFinite(admission.sampledAt) || !(admission.validUntil > now) || typeof admission.allowHeavy !== "boolean" || !admission.resources?.sample) {
+    return [title, "\u6682\u65E0\u6709\u6548\u7684\u8FD0\u884C\u91C7\u6837\u3002\u8BF7\u68C0\u67E5\u706B\u706B\u670D\u52A1\u662F\u5426\u6B63\u5728\u8FD0\u884C\u3002"];
+  }
+  const { sample, reasons } = admission.resources;
+  const needed = installed.release.budget.heavyJobHeadroomBytes;
+  const gap = sample.availableMemoryBytes === null ? null : Math.max(0, needed - sample.availableMemoryBytes);
+  const lines = [
+    title,
+    `\u540E\u53F0\u7814\u7A76  ${admission.allowHeavy ? "\u53EF\u63A5\u6536\u4EFB\u52A1" : "\u6682\u7F13\u65B0\u4EFB\u52A1"}`,
+    `\u7CFB\u7EDF\u5185\u5B58  \u53EF\u7528 ${mib(sample.availableMemoryBytes)} / \u603B\u5BB9\u91CF ${mib(sample.effectiveMemoryBytes)}`,
+    `\u4EFB\u52A1\u95E8\u69DB  \u9884\u7559 ${mib(needed)}${gap ? `\uFF0C\u8FD8\u5DEE ${mib(gap)}` : ""}`,
+    `\u5185\u5B58\u538B\u529B  ${pressureLabels[sample.pressure] ?? "\u672A\u77E5"}`,
+    `\u706B\u706B\u8FDB\u7A0B  \u4F30\u7B97\u5360\u7528 ${mib(admission.rssSumEstimateBytes)}`
+  ];
+  if (!admission.allowHeavy) lines.push(reasons?.[0] ? `\u6682\u7F13\u539F\u56E0  ${reasons[0]}` : "\u6B63\u5728\u7B49\u5F85\u8FDE\u7EED\u5065\u5EB7\u91C7\u6837\u3002");
+  lines.push(`\u91C7\u6837\u65F6\u95F4  ${new Date(admission.sampledAt * 1e3).toLocaleTimeString()}`);
+  return lines;
+}
+async function showStatus(home, watch) {
+  const output = process.stdout;
+  if (!watch || !output.isTTY || process.env.TERM === "dumb") {
+    output.write((await statusLines(home)).join("\n") + "\n");
+    return;
+  }
+  const stop = new AbortController();
+  const close = () => stop.abort();
+  const input = process.stdin;
+  const raw = input.isTTY;
+  const wasRaw = input.isRaw;
+  const onKey = (chunk) => {
+    if (chunk.includes(3)) close();
+  };
+  process.once("SIGINT", close);
+  process.once("SIGTERM", close);
+  try {
+    if (raw) {
+      input.setRawMode(true);
+      input.on("data", onKey);
+      input.resume();
+    }
+    output.write("\x1B[?1049h\x1B[?25l");
+    while (!stop.signal.aborted) {
+      const lines = await statusLines(home);
+      if (stop.signal.aborted) break;
+      output.write("\x1B[H\x1B[0J" + [...lines, "", "\u6BCF 2 \u79D2\u5237\u65B0 \xB7 Ctrl+C \u5173\u95ED\u770B\u677F"].join("\n"));
+      await delay2(2e3, void 0, { signal: stop.signal }).catch((error) => {
+        if (!stop.signal.aborted) throw error;
+      });
+    }
+  } finally {
+    output.write("\x1B[?25h\x1B[?1049l");
+    if (raw) {
+      input.off("data", onKey);
+      input.setRawMode(Boolean(wasRaw));
+      input.pause();
+    }
+    process.off("SIGINT", close);
+    process.off("SIGTERM", close);
+  }
+}
+
 // distribution/bootstrap/entry.ts
 function artifactSource(source, directory) {
   return async (url, options) => {
+    const bundled = /^https:\/\/bundled\.invalid\/([a-f0-9]{64})\.tgz$/.exec(String(url));
+    if (!directory && !bundled) return fetch(url, options);
     const artifact2 = source && [source.runtime, source.python, source.pythonDependencies].find((item) => item.url === String(url));
-    if (!directory && !artifact2?.bundled) return fetch(url, options);
-    if (!artifact2) throw new Error("\u672C\u673A\u4EA7\u7269\u76EE\u5F55\u7F3A\u5C11\u8BE5\u56FA\u5B9A\u53D1\u884C\u8D44\u6E90");
-    const root = directory ?? join6(dirname5(fileURLToPath(import.meta.url)), "assets");
-    return new Response(Readable.toWeb(createReadStream2(join6(root, artifact2.sha256 + ".tgz"), { signal: options?.signal ?? void 0 })));
+    const sha256 = bundled?.[1] ?? artifact2?.sha256;
+    if (!sha256) throw new Error("\u672C\u673A\u4EA7\u7269\u76EE\u5F55\u7F3A\u5C11\u8BE5\u56FA\u5B9A\u53D1\u884C\u8D44\u6E90");
+    const root = directory ?? join7(dirname5(fileURLToPath(import.meta.url)), "assets");
+    const path = join7(root, sha256 + ".tgz");
+    const file = await open3(path).catch((error) => {
+      if (error.code === "ENOENT" && bundled) throw new Error("\u7F3A\u5C11\u4E0A\u6B21\u5B89\u88C5\u4F7F\u7528\u7684\u6587\u4EF6\u3002\u8BF7\u7528\u4E0A\u6B21\u5B89\u88C5\u65F6\u7684\u7248\u672C\u7EE7\u7EED\u3002");
+      throw error;
+    });
+    return new Response(Readable.toWeb(file.createReadStream({ signal: options?.signal ?? void 0 })));
   };
 }
 async function main(args = process.argv.slice(2)) {
-  let home = join6(homedir(), ".huohuo"), noOpen = false, command = "start";
+  let home = join7(homedir(), ".huohuo"), noOpen = false, assumeYes = false, watch = false, command = "start";
   let releaseFile, artifactDirectory;
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--home") {
@@ -1069,19 +1363,23 @@ async function main(args = process.argv.slice(2)) {
       if (option === "--release") releaseFile = resolve5(args[++i]);
       else artifactDirectory = resolve5(args[++i]);
     } else if (args[i] === "--no-open") noOpen = true;
+    else if (args[i] === "--yes") assumeYes = true;
+    else if (args[i] === "--watch") watch = true;
     else if (args[i] === "--version") {
-      const packageFile = join6(dirname5(fileURLToPath(import.meta.url)), "package.json");
-      const manifest = JSON.parse(await readFile7(packageFile, "utf8"));
+      const packageFile = join7(dirname5(fileURLToPath(import.meta.url)), "package.json");
+      const manifest = JSON.parse(await readFile8(packageFile, "utf8"));
       console.log(`${manifest.name} ${manifest.version}${manifest.private ? "\uFF08\u672C\u5730\u5019\u9009\uFF09" : ""}`);
       return;
-    } else if (["start", "doctor", "stop", "upgrade", "uninstall"].includes(args[i])) command = args[i];
-    else throw new Error("\u7528\u6CD5\uFF1Ahuohuo [start|doctor|stop|upgrade|uninstall] [--home \u76EE\u5F55] [--no-open]");
+    } else if (["start", "status", "doctor", "stop", "upgrade", "uninstall"].includes(args[i])) command = args[i];
+    else throw new Error("\u7528\u6CD5\uFF1Ahuohuo [start|status|doctor|stop|upgrade|uninstall] [--home \u76EE\u5F55] [--no-open]");
   }
+  if (watch && command !== "status") throw new Error("--watch \u8BF7\u4E0E status \u4E00\u8D77\u4F7F\u7528");
   try {
     home = await realpath5(home);
   } catch (e) {
     if (e.code !== "ENOENT") throw e;
   }
+  if (command === "status") return showStatus(home, watch);
   let record = await readInstallation(home);
   const labels = {
     preflight: "\u68C0\u67E5\u672C\u673A\u73AF\u5883",
@@ -1089,15 +1387,22 @@ async function main(args = process.argv.slice(2)) {
     "install-runtime": "\u51C6\u5907 Python \u8FD0\u884C\u73AF\u5883",
     "install-dependencies": "\u5B89\u88C5\u706B\u706B\u4E0E\u56FA\u5B9A\u4F9D\u8D56",
     "assemble-profiles": "\u914D\u7F6E\u5BF9\u8BDD\u4E0E\u540E\u53F0\u7814\u7A76",
-    verify: "\u68C0\u67E5\u5B89\u88C5\u7ED3\u679C"
+    verify: "\u68C0\u67E5\u5B89\u88C5\u7ED3\u679C",
+    "resume-current-package": "\u4E0A\u6B21\u5B89\u88C5\u5C1A\u672A\u5199\u5165\u8FD0\u884C\u73AF\u5883\uFF0C\u5C06\u4F7F\u7528\u5F53\u524D\u7248\u672C\u91CD\u65B0\u68C0\u67E5"
   };
-  const progress = (stage) => console.log(`\u706B\u706B\uFF1A${labels[stage] ?? stage}`);
+  const installStages = ["preflight", "download", "install-runtime", "install-dependencies", "assemble-profiles", "verify"];
+  const progress = (stage) => {
+    const index = command === "start" ? installStages.indexOf(stage) : -1;
+    const step = index < 0 ? "" : `[${index + 1}/${installStages.length}] `;
+    console.log(`\u706B\u706B\uFF1A${step}${labels[stage] ?? stage}`);
+  };
+  const ui = installUI(assumeYes);
   if (command === "upgrade") {
-    const candidate = JSON.parse(await readFile7(releaseFile ?? join6(dirname5(fileURLToPath(import.meta.url)), "release.json"), "utf8"));
-    await upgrade(home, candidate, { fetcher: artifactSource(candidate, artifactDirectory), progress });
+    const candidate = JSON.parse(await readFile8(releaseFile ?? join7(dirname5(fileURLToPath(import.meta.url)), "release.json"), "utf8"));
+    await upgrade(home, candidate, { fetcher: artifactSource(candidate, artifactDirectory), progress, ...ui });
     const current = await readInstallation(home);
     if (await control(home, current.releaseDigest, noOpen ? "status" : "open")) return;
-    await run(process.execPath, [join6(installationPaths(home, current.release).runtime, "lib/distribution/managed.js"), "start", home, ...noOpen ? ["--no-open"] : []], home);
+    await run(process.execPath, [join7(installationPaths(home, current.release).runtime, "lib/distribution/managed.js"), "start", home, ...noOpen ? ["--no-open"] : []], home);
     return;
   }
   if (command === "uninstall") {
@@ -1115,7 +1420,7 @@ async function main(args = process.argv.slice(2)) {
       return;
     }
     const paths = installationPaths(home, record.release);
-    const targets = [home, paths.directory, paths.environment, join6(home, "instances/default")];
+    const targets = [home, paths.directory, paths.environment, join7(home, "instances/default")];
     const resources = evaluateResources(await sampleResources(targets), record.release.budget, targets.map((path) => ({ path, bytes: 0 })), "start");
     console.log(JSON.stringify({
       home,
@@ -1136,7 +1441,7 @@ async function main(args = process.argv.slice(2)) {
     }
     const runtime = installationPaths(home, record.release).runtime;
     try {
-      await readFile7(join6(runtime, "lib/distribution/managed.js"));
+      await readFile8(join7(runtime, "lib/distribution/managed.js"));
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
       record = void 0;
@@ -1144,24 +1449,25 @@ async function main(args = process.argv.slice(2)) {
   }
   if (!record || record.status !== "ready") {
     let catalog = null;
-    if (!record) {
+    if (!record || ["preflight", "download"].includes(record.stage)) {
       try {
-        catalog = JSON.parse(await readFile7(releaseFile ?? join6(dirname5(fileURLToPath(import.meta.url)), "release.json"), "utf8"));
+        catalog = JSON.parse(await readFile8(releaseFile ?? join7(dirname5(fileURLToPath(import.meta.url)), "release.json"), "utf8"));
       } catch (e) {
         if (e.code !== "ENOENT") throw e;
       }
     }
     const source = (await readInstallation(home))?.release ?? catalog;
     const fetcher = artifactSource(source, artifactDirectory);
-    record = await install(home, catalog, { fetcher, progress });
+    const bundleDirectory = !releaseFile && !artifactDirectory ? join7(dirname5(fileURLToPath(import.meta.url)), "assets") : void 0;
+    record = await install(home, catalog, { fetcher, progress, bundleDirectory, ...ui });
   }
   const installedHome = record.home;
-  await run(process.execPath, [join6(installationPaths(installedHome, record.release).runtime, "lib/distribution/managed.js"), "start", installedHome, ...noOpen ? ["--no-open"] : []], installedHome);
+  await run(process.execPath, [join7(installationPaths(installedHome, record.release).runtime, "lib/distribution/managed.js"), "start", installedHome, ...noOpen ? ["--no-open"] : []], installedHome);
 }
 if (process.argv[1] && await realpath5(resolve5(process.argv[1])).catch(() => "") === await realpath5(fileURLToPath(import.meta.url))) {
   main().catch((error) => {
     console.error(error instanceof Error ? error.message : "\u5B89\u88C5\u6216\u542F\u52A8\u5931\u8D25");
-    process.exitCode = 1;
+    if (error?.code !== "INSTALL_CANCELLED") process.exitCode = 1;
   });
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pab-iprg/huohuo",
-  "version": "1.0.0-preview.2",
+  "version": "1.0.0-preview.4",
   "type": "module",
   "description": "火火投研伙伴安装入口",
   "bin": {

package/release.json

@@ -13,11 +13,11 @@
   "runtime": {
     "name": "@huohuo/research-agent",
     "version": "1.0.0",
-    "url": "https://bundled.invalid/3126256d1e3ad445b74f67e0a97a339774bc23cdcc5249578f1c9e1b7f3d8f6d.tgz",
-    "sha256": "3126256d1e3ad445b74f67e0a97a339774bc23cdcc5249578f1c9e1b7f3d8f6d",
-    "integrity": "sha512-KmCItvQmE0LZbNiKdrWeYsUCD4p4YaBfiS+OOwsepOix03nON46tgpFgOeT/effrEWzPROmuwI64IU8g4loTYw==",
-    "downloadBytes": 2542537,
-    "expandedBytes": 8237483,
+    "url": "https://bundled.invalid/550095205f2f92e0641b286f15fbb01ece0b29339ecf7c5ee18539a2b7f5def8.tgz",
+    "sha256": "550095205f2f92e0641b286f15fbb01ece0b29339ecf7c5ee18539a2b7f5def8",
+    "integrity": "sha512-AI87lAFcPyGM5qtQ4B2Ji3CJWE10twn48t0tSnuEeIxlVAKVEJBWRe7aSCkOKwLvpeai8CRts50oEMh0juDWrA==",
+    "downloadBytes": 2548683,
+    "expandedBytes": 8255144,
     "bundled": true
   },
   "python": {
@@ -37,7 +37,8 @@
     "sha256": "4f008fe4491617729554e056ad59eee686ccc5d95c9f1d5259da705bf054ce21",
     "downloadBytes": 10235,
     "expandedBytes": 15007,
-    "bundled": true
+    "bundled": true,
+    "upstreamWheelCount": 39
   },
   "dsh": {
     "version": "0.2.1-rc.2",
@@ -56,7 +57,8 @@
     "sampleMaxAgeMs": 10000,
     "installTemporaryBytes": 1073741824,
     "dependenciesBytes": 4294967296,
-    "backupBytes": 0
+    "backupBytes": 0,
+    "observedInstallRssBytes": 1904771072
   },
   "schema": {
     "minimum": 1,