@pab-iprg/huohuo 0.0.0-stage → 1.0.0-preview.2

package/README.md

@@ -1,3 +1,13 @@
-# Temporary Holding Version
+# 火火安装入口
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+入口在设备预检后安装 DSH 和火火运行环境。npm 预览包内置火火运行文件，Python 运行时和依赖从固定上游地址获取并校验摘要。
+
+构建时需要已完成平台测量与摘要绑定的 `release.json`。没有发行清单时入口明确停止，不从不可信页面选择资源，也不使用虚构的最低配置。
+
+发布后的预览入口为 `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]`。
+
+显式升级检查旧迁移不可变、追加迁移顺序、执行库格式与 DSH 会话兼容范围，先一致性备份再迁移和验证，成功后切换；不自动恢复旧备份覆盖新数据。默认卸载保留实例、凭据、会话和备份，不提供直接彻底删除业务数据的快捷入口。
+
+首版终端前台管理生命周期，Ctrl+C 停止本次实例。退出终端、休眠或关机后不承诺持续运行。模型凭据在现有设置页面填写，安装检查不调用真实模型或通知。

package/cli.js

@@ -0,0 +1,1169 @@
+#!/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 { Readable } from "node:stream";
+import { homedir } from "node:os";
+import { dirname as dirname5, join as join6, resolve as resolve5 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// distribution/bootstrap/install.ts
+import { readFile as readFile4, mkdir as mkdir3, access, rename as rename3, rm as rm2, realpath as realpath3, readdir } from "node:fs/promises";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
+import { join as join3, resolve as resolve3 } from "node:path";
+import { release as osRelease } from "node:os";
+import { spawn, execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+
+// distribution/bootstrap/state.ts
+import { open, rename, unlink, readFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execute = promisify(execFile);
+async function processIdentity(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0 || !["darwin", "linux"].includes(process.platform)) throw new Error("\u8FDB\u7A0B\u542F\u52A8\u8EAB\u4EFD\u63A2\u9488\u4E0D\u652F\u6301\u6216\u65E0\u6548");
+  try {
+    const { stdout } = await execute("ps", ["-p", String(pid), "-o", "lstart=,uid="], { timeout: 2e3 });
+    if (!stdout.trim()) throw new Error("\u8FDB\u7A0B\u542F\u52A8\u8EAB\u4EFD\u63A2\u9488\u8FD4\u56DE\u7A7A\u503C");
+    return stdout.trim().replace(/\s+/g, " ");
+  } catch (e) {
+    if (e.code === 1 && !String(e.stdout ?? "").trim()) {
+      try {
+        process.kill(pid, 0);
+      } catch (signalError) {
+        if (signalError.code === "ESRCH") return null;
+      }
+    }
+    throw new Error("\u8FDB\u7A0B\u542F\u52A8\u8EAB\u4EFD\u65E0\u6CD5\u6838\u9A8C\uFF1B\u672A\u56DE\u6536\u9501");
+  }
+}
+async function isLockOwnerDead(path, token) {
+  try {
+    const previous = JSON.parse(await readFile(path, "utf8"));
+    return previous.format === 1 && previous.path === path && previous.uid === process.getuid?.() && typeof previous.processStart === "string" && !!previous.processStart && typeof previous.token === "string" && /^[a-f0-9-]{36}$/.test(previous.token) && (token === void 0 || previous.token === token) && Number.isSafeInteger(previous.pid) && await processIdentity(previous.pid) === null;
+  } catch {
+    return false;
+  }
+}
+async function atomicJSON(path, value) {
+  const pending = `${path}.${randomUUID()}.tmp`;
+  const file = await open(pending, "wx", 384);
+  try {
+    await file.writeFile(JSON.stringify(value, null, 2) + "\n");
+    await file.sync();
+  } catch (error) {
+    await unlink(pending).catch(() => {
+    });
+    throw error;
+  } finally {
+    await file.close();
+  }
+  try {
+    await rename(pending, path);
+    const directory = await open(dirname(path), "r");
+    try {
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  } finally {
+    await unlink(pending).catch(() => {
+    });
+  }
+}
+async function acquireLock(path) {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  let lock;
+  try {
+    lock = await open(path, "wx", 384);
+  } catch (cause) {
+    if (cause.code !== "EEXIST") throw cause;
+    let recovery;
+    try {
+      recovery = await open(path + ".reconcile", "wx", 384);
+      const previous = JSON.parse(await readFile(path, "utf8"));
+      if (!await isLockOwnerDead(path, previous.token)) throw new Error("\u9501\u5F52\u5C5E\u672A\u786E\u8BA4\u6216\u8FDB\u7A0B\u4ECD\u5B58\u5728");
+      await rename(path, `${path}.stale-${randomUUID()}`);
+      lock = await open(path, "wx", 384);
+    } catch {
+      throw new Error("\u5B89\u88C5\u6216\u5B9E\u4F8B\u9501\u5DF2\u5B58\u5728\uFF1B\u4E0D\u80FD\u4EC5\u51ED PID \u6216\u8D85\u65F6\u63A5\u7BA1\u3002\u8BF7\u7528 doctor \u6838\u5BF9\u672C\u673A\u8FDB\u7A0B\u4E0E\u9501\u5F52\u5C5E\u3002", { cause });
+    } finally {
+      if (recovery) {
+        await recovery.close();
+        await unlink(path + ".reconcile");
+      }
+    }
+  }
+  const token = randomUUID();
+  try {
+    const processStart = await processIdentity(process.pid);
+    if (!processStart) throw new Error("\u5F53\u524D\u8FDB\u7A0B\u542F\u52A8\u8EAB\u4EFD\u672A\u77E5");
+    await lock.writeFile(JSON.stringify({ format: 1, path, uid: process.getuid?.(), pid: process.pid, processStart, startedAt: (/* @__PURE__ */ new Date()).toISOString(), token }));
+    await lock.sync();
+  } catch (error) {
+    await lock.close();
+    await unlink(path);
+    throw error;
+  }
+  return async () => {
+    await lock.close();
+    try {
+      const current = JSON.parse(await readFile(path, "utf8"));
+      if (current.token === token) await unlink(path);
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+  };
+}
+async function withLock(path, action) {
+  const release = await acquireLock(path);
+  try {
+    return await action();
+  } finally {
+    await release();
+  }
+}
+
+// distribution/bootstrap/release.ts
+var version = /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?$/;
+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;
+  try {
+    const u = new URL(a.url);
+    return u.protocol === "https:" && !u.username && !u.password && !u.hash;
+  } catch {
+    return false;
+  }
+}
+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 || ![
+    "minimumEffectiveMemoryBytes",
+    "startupHeadroomBytes",
+    "heavyJobHeadroomBytes",
+    "diskReserveBytes",
+    "recoverySamples",
+    "installTemporaryBytes",
+    "dependenciesBytes",
+    "backupBytes",
+    "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) {
+    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");
+  if (!r.schema.files || !Object.keys(r.schema.files).length || !Object.entries(r.schema.files).every(([name, sha]) => /^\d{3}_[a-z0-9_]+\.sql$/.test(name) && hash.test(sha))) throw new Error("\u6570\u636E\u5E93\u8FC1\u79FB\u6587\u4EF6\u6E05\u5355\u65E0\u6548");
+  return r;
+}
+
+// distribution/bootstrap/artifact.ts
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir as mkdir2, open as open2, rename as rename2, rm, realpath, symlink, link, lstat } from "node:fs/promises";
+import { dirname as dirname2, resolve, sep, posix } from "node:path";
+import { createGunzip } from "node:zlib";
+async function verifyArtifact(path, artifact2) {
+  const digest2 = createHash("sha256"), integrity = createHash("sha512");
+  let bytes = 0;
+  for await (const chunk of createReadStream(path)) {
+    bytes += chunk.length;
+    digest2.update(chunk);
+    integrity.update(chunk);
+  }
+  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) {
+  try {
+    await verifyArtifact(path, artifact2);
+    return;
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  await mkdir2(dirname2(path), { recursive: true, mode: 448 });
+  const pending = `${path}.${randomUUID2()}.partial`;
+  const handle = await open2(pending, "wx", 384);
+  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");
+      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 (!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;
+      if (received > artifact2.downloadBytes) throw new Error("\u4E0B\u8F7D\u8D85\u8FC7\u53D1\u884C\u6E05\u5355\u5927\u5C0F");
+      await handle.writeFile(chunk);
+    }
+    await handle.sync();
+    await handle.close();
+    await verifyArtifact(pending, artifact2);
+    await rename2(pending, path);
+  } finally {
+    await handle.close().catch(() => {
+    });
+    await rm(pending, { force: true });
+  }
+}
+function safePath(root, path) {
+  if (!path || path.includes("\\") || path.includes("\0") || path.startsWith("/") || /^[A-Za-z]:/.test(path) || path.split("/").includes("..")) throw new Error("\u538B\u7F29\u5305\u8DEF\u5F84\u8D8A\u754C");
+  const target = resolve(root, path);
+  if (target !== root && !target.startsWith(root + sep)) throw new Error("\u538B\u7F29\u5305\u8DEF\u5F84\u8D8A\u754C");
+  return target;
+}
+async function extractArchive(archive, root, expandedLimit) {
+  root = resolve(root);
+  await mkdir2(root, { mode: 448 });
+  root = await realpath(root);
+  const stream = createReadStream(archive).pipe(createGunzip());
+  const iterator = stream[Symbol.asyncIterator]();
+  let buffer = Buffer.alloc(0), expanded = 0, count = 0;
+  const take = async (size) => {
+    while (buffer.length < size) {
+      const next = await iterator.next();
+      if (next.done) throw new Error("\u538B\u7F29\u5305\u63D0\u524D\u7ED3\u675F");
+      buffer = Buffer.concat([buffer, Buffer.from(next.value)]);
+    }
+    const value = buffer.subarray(0, size);
+    buffer = buffer.subarray(size);
+    return value;
+  };
+  const string = (b) => b.toString("utf8").replace(/\0.*$/s, "");
+  const links = [];
+  let pax = {};
+  try {
+    while (true) {
+      const header = await take(512);
+      if (header.every((byte) => byte === 0)) break;
+      if (++count > 2e5) throw new Error("\u538B\u7F29\u5305\u6587\u4EF6\u6570\u8D85\u9650");
+      const checksum = parseInt(string(header.subarray(148, 156)).trim(), 8);
+      const actual = header.reduce((sum, byte, i) => sum + (i >= 148 && i < 156 ? 32 : byte), 0);
+      if (checksum !== actual) throw new Error("\u538B\u7F29\u5305\u5934\u6821\u9A8C\u5931\u8D25");
+      const sizeText = string(header.subarray(124, 136)).trim();
+      if (!/^[0-7]+$/.test(sizeText)) throw new Error("\u538B\u7F29\u5305\u6587\u4EF6\u5927\u5C0F\u65E0\u6548");
+      const size = parseInt(sizeText, 8), kind = String.fromCharCode(header[156] || 48);
+      expanded += size;
+      if (!Number.isSafeInteger(size) || expanded > expandedLimit) throw new Error("\u89E3\u538B\u8D85\u8FC7\u53D1\u884C\u9884\u7B97");
+      if (kind === "x") {
+        if (size > 64 * 1024) throw new Error("\u538B\u7F29\u5305\u6269\u5C55\u5934\u8D85\u9650");
+        const data = await take(size);
+        let offset = 0;
+        pax = {};
+        while (offset < data.length) {
+          const space = data.indexOf(32, offset), length = Number(data.subarray(offset, space).toString());
+          if (space < 0 || !Number.isSafeInteger(length) || length <= space - offset + 1 || offset + length > data.length) throw new Error("\u538B\u7F29\u5305\u6269\u5C55\u5934\u65E0\u6548");
+          const record = data.subarray(space + 1, offset + length - 1).toString("utf8"), equal = record.indexOf("=");
+          if (equal < 1) throw new Error("\u538B\u7F29\u5305\u6269\u5C55\u5934\u65E0\u6548");
+          pax[record.slice(0, equal)] = record.slice(equal + 1);
+          offset += length;
+        }
+      } else {
+        const prefix = string(header.subarray(345, 500));
+        const name = pax.path ?? (prefix ? prefix + "/" : "") + string(header.subarray(0, 100));
+        const target = safePath(root, name);
+        const linkText = pax.linkpath ?? string(header.subarray(157, 257));
+        if (Object.keys(pax).some((key) => /sparse|size/i.test(key))) throw new Error("\u4E0D\u652F\u6301\u7A00\u758F\u6216\u6539\u5199\u5927\u5C0F\u7684\u538B\u7F29\u5305");
+        pax = {};
+        await mkdir2(dirname2(target), { recursive: true, mode: 448 });
+        if (kind === "5") {
+          if (size) throw new Error("\u76EE\u5F55\u643A\u5E26\u6570\u636E");
+          await mkdir2(target, { recursive: true, mode: 448 });
+        } else if (kind === "0") {
+          const mode = parseInt(string(header.subarray(100, 108)).trim(), 8);
+          const file = await open2(target, "wx", mode & 73 ? 448 : 384);
+          try {
+            let remaining = size;
+            while (remaining) {
+              const chunk = await take(Math.min(remaining, 64 * 1024));
+              await file.writeFile(chunk);
+              remaining -= chunk.length;
+            }
+          } finally {
+            await file.close();
+          }
+        } else if (kind === "1" || kind === "2") {
+          if (size || !linkText || linkText.startsWith("/") || linkText.includes("\\")) throw new Error("\u538B\u7F29\u5305\u94FE\u63A5\u65E0\u6548");
+          const relative = kind === "2" ? posix.normalize(posix.join(posix.dirname(name), linkText)) : linkText;
+          links.push({ target, source: safePath(root, relative), symbolic: kind === "2", text: linkText });
+        } else throw new Error(`\u538B\u7F29\u5305\u6761\u76EE\u7C7B\u578B\u4E0D\u53D7\u652F\u6301\uFF1A${kind}`);
+      }
+      if (size % 512) await take(512 - size % 512);
+    }
+    let pending = links;
+    while (pending.length) {
+      const later = [];
+      for (const item of pending) {
+        let source;
+        try {
+          source = await realpath(item.source);
+        } catch (e) {
+          if (e.code === "ENOENT") {
+            later.push(item);
+            continue;
+          }
+          throw e;
+        }
+        if (!source.startsWith(root + sep) || !(await lstat(source)).isFile()) throw new Error("\u94FE\u63A5\u5FC5\u987B\u6307\u5411\u5305\u5185\u666E\u901A\u6587\u4EF6");
+        if (item.symbolic) await symlink(item.text, item.target);
+        else await link(source, item.target);
+      }
+      if (later.length === pending.length) throw new Error("\u538B\u7F29\u5305\u94FE\u63A5\u7F3A\u5931\u6216\u5FAA\u73AF");
+      pending = later;
+    }
+  } finally {
+    stream.destroy();
+  }
+}
+
+// distribution/bootstrap/resources.ts
+import { availableParallelism, totalmem } from "node:os";
+import { availableMemory, constrainedMemory } from "node:process";
+import { readFile as readFile3, realpath as realpath2, stat, statfs } from "node:fs/promises";
+import { dirname as dirname3, resolve as resolve2, sep as sep2 } from "node:path";
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execute2 = promisify2(execFile2);
+async function existingParent(path) {
+  let current = resolve2(path);
+  while (true) {
+    try {
+      await stat(current);
+      return current;
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+    const parent = dirname3(current);
+    if (parent === current) throw new Error("\u6CA1\u6709\u53EF\u8BFB\u53D6\u7684\u6587\u4EF6\u7CFB\u7EDF\u7236\u76EE\u5F55");
+    current = parent;
+  }
+}
+async function sampleResources(paths) {
+  const limit = constrainedMemory();
+  let effectiveMemoryBytes = Math.min(totalmem(), limit || Infinity);
+  let availableMemoryBytes = null;
+  let pressure = "unknown";
+  try {
+    availableMemoryBytes = availableMemory();
+    if (!(availableMemoryBytes > 0)) availableMemoryBytes = null;
+  } catch {
+  }
+  if (!(effectiveMemoryBytes > 0)) effectiveMemoryBytes = null;
+  if (process.platform === "darwin") {
+    try {
+      const { stdout } = await execute2("/usr/sbin/sysctl", ["-n", "kern.memorystatus_vm_pressure_level"], { timeout: 2e3 });
+      pressure = { 1: "normal", 2: "high", 4: "critical" }[Number(stdout.trim())] ?? "unknown";
+    } catch {
+    }
+    if (pressure === "normal" && availableMemoryBytes !== null && effectiveMemoryBytes !== null) {
+      try {
+        const { stdout } = await execute2("/usr/bin/vm_stat", [], { timeout: 2e3 });
+        const pageBytes = Number(/page size of (\d+) bytes/.exec(stdout)?.[1]);
+        const pageCounts = ["free", "purgeable"].map((kind) => Number(new RegExp(`^Pages ${kind}:\\s+(\\d+)\\.`, "m").exec(stdout)?.[1]));
+        const reclaimable = pageBytes * pageCounts.reduce((sum, pages) => sum + pages, 0);
+        if (Number.isSafeInteger(reclaimable) && reclaimable > 0) {
+          availableMemoryBytes = Math.min(effectiveMemoryBytes, Math.max(availableMemoryBytes, reclaimable));
+        }
+      } catch {
+      }
+    }
+  } else if (process.platform === "linux") {
+    try {
+      const info = await readFile3("/proc/meminfo", "utf8");
+      const available = /^MemAvailable:\s+(\d+) kB$/m.exec(info);
+      if (available) availableMemoryBytes = Math.min(availableMemoryBytes ?? Infinity, Number(available[1]) * 1024);
+      if (limit) {
+        try {
+          const current = Number((await readFile3("/sys/fs/cgroup/memory.current", "utf8")).trim());
+          if (Number.isFinite(current)) availableMemoryBytes = Math.min(availableMemoryBytes ?? Infinity, Math.max(0, limit - current));
+        } catch {
+          availableMemoryBytes = null;
+        }
+      }
+      const psi = await readFile3("/proc/pressure/memory", "utf8");
+      const full = /^full avg10=(\d+(?:\.\d+)?)/m.exec(psi);
+      if (full) pressure = Number(full[1]) > 0 ? "high" : "normal";
+    } catch {
+    }
+  }
+  const disks = [];
+  for (const path of [...new Set(paths.map((p) => resolve2(p)))]) {
+    try {
+      const parent = await realpath2(await existingParent(path));
+      const [meta, space] = await Promise.all([stat(parent), statfs(parent, { bigint: true })]);
+      const device = String(meta.dev);
+      const bytes = space.bavail * space.bsize;
+      const availableBytes = bytes >= 0n && bytes <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(bytes) : null;
+      const disk = disks.find((d) => d.device === device);
+      if (disk) {
+        disk.paths.push(path);
+        disk.availableBytes = disk.availableBytes === null || availableBytes === null ? null : Math.min(disk.availableBytes, availableBytes);
+      } else disks.push({ device, availableBytes, paths: [path] });
+    } catch {
+      disks.push({ device: `unknown:${path}`, availableBytes: null, paths: [path] });
+    }
+  }
+  return { effectiveMemoryBytes, availableMemoryBytes, pressure, disks, sampledAt: (/* @__PURE__ */ new Date()).toISOString(), adapter: `${process.platform}/${process.arch}/node-${process.versions.node}` };
+}
+function diskBudgets(sample, costs, reserve) {
+  const budgets = /* @__PURE__ */ new Map();
+  for (const cost of costs) {
+    const candidates = sample.disks.flatMap((d) => d.paths.map((path) => ({ disk: d, path }))).filter(({ path }) => cost.path === path || cost.path.startsWith(path.endsWith(sep2) ? path : path + sep2)).sort((a, b) => b.path.length - a.path.length);
+    const disk = candidates[0]?.disk;
+    const device = disk?.device ?? `unknown:${cost.path}`;
+    const budget = budgets.get(device) ?? { device, availableBytes: disk?.availableBytes ?? null, requiredBytes: reserve };
+    budget.requiredBytes += cost.bytes;
+    budgets.set(device, budget);
+  }
+  return [...budgets.values()];
+}
+function evaluateResources(sample, policy, costs, phase) {
+  const reasons = [];
+  let blocked = false, unknown = false, limited = false;
+  if (sample.effectiveMemoryBytes === null || sample.availableMemoryBytes === null) {
+    unknown = true;
+    reasons.push("\u5173\u952E\u5185\u5B58\u63A2\u9488\u672A\u77E5");
+  }
+  if (sample.effectiveMemoryBytes !== null && sample.effectiveMemoryBytes < policy.minimumEffectiveMemoryBytes) {
+    blocked = true;
+    reasons.push("\u6709\u6548\u5185\u5B58\u5BB9\u91CF\u4E0D\u8DB3");
+  }
+  const needed = phase === "heavy" ? policy.heavyJobHeadroomBytes : policy.startupHeadroomBytes;
+  if (sample.availableMemoryBytes !== null && sample.availableMemoryBytes < needed) {
+    blocked = true;
+    reasons.push("\u5F53\u524D\u5185\u5B58\u4F59\u91CF\u4E0D\u8DB3");
+  }
+  if (sample.pressure === "critical") {
+    blocked = true;
+    reasons.push("\u7CFB\u7EDF\u5185\u5B58\u538B\u529B\u4E25\u91CD");
+  }
+  const disks = diskBudgets(sample, costs, policy.diskReserveBytes);
+  for (const disk of disks) {
+    if (disk.availableBytes === null) {
+      unknown = true;
+      reasons.push(`\u6587\u4EF6\u7CFB\u7EDF\u53EF\u7528\u7A7A\u95F4\u672A\u77E5\uFF1A${disk.device}`);
+    } else if (disk.availableBytes < disk.requiredBytes) {
+      blocked = true;
+      const available = (disk.availableBytes / 1e9).toFixed(2);
+      const required = (disk.requiredBytes / 1e9).toFixed(2);
+      const missing = (Math.ceil((disk.requiredBytes - disk.availableBytes) / 1e7) / 100).toFixed(2);
+      reasons.push(`\u78C1\u76D8\u7A7A\u95F4\u4E0D\u8DB3\uFF1A\u5269\u4F59 ${available} GB\uFF0C\u9700\u8981 ${required} GB\u3002\u8BF7\u81F3\u5C11\u518D\u817E\u51FA ${missing} GB\u3002`);
+    }
+  }
+  if (sample.pressure === "high" || sample.pressure === "unknown") {
+    limited = true;
+    reasons.push(sample.pressure === "high" ? "\u5F53\u524D\u5185\u5B58\u6BD4\u8F83\u7D27\u5F20\uFF0C\u53EF\u4EE5\u5148\u5173\u95ED\u6682\u65F6\u4E0D\u7528\u7684\u5E94\u7528\u3002" : "\u6682\u65F6\u65E0\u6CD5\u786E\u8BA4\u5185\u5B58\u538B\u529B\u3002");
+  }
+  const status = blocked ? "blocked" : unknown ? "unknown" : limited ? "limited" : "pass";
+  return { status, reasons, disks, sample, policy, concurrency: status === "pass" ? Math.min(1, availableParallelism()) : 0 };
+}
+
+// runtime/npm.mjs
+import { existsSync } from "node:fs";
+import { dirname as dirname4, join as join2 } from "node:path";
+function npmCommand() {
+  if (process.platform !== "win32") return { command: "npm", prefix: [] };
+  const cli = join2(dirname4(process.execPath), "node_modules", "npm", "bin", "npm-cli.js");
+  if (existsSync(cli)) return { command: process.execPath, prefix: [cli] };
+  return { command: process.env.ComSpec ?? "cmd.exe", prefix: ["/d", "/s", "/c", "npm"] };
+}
+
+// distribution/bootstrap/install.ts
+var digest = (value) => createHash2("sha256").update(JSON.stringify(value)).digest("hex");
+async function ownedDirectory(path, owner) {
+  await mkdir3(resolve3(path, ".."), { recursive: true, mode: 448 });
+  try {
+    await mkdir3(path, { mode: 448 });
+    await atomicJSON(join3(path, ".huohuo-owner.json"), { format: 1, owner });
+  } catch (e) {
+    if (e.code !== "EEXIST") throw e;
+    const marker = JSON.parse(await readFile4(join3(path, ".huohuo-owner.json"), "utf8"));
+    if (marker.format !== 1 || marker.owner !== owner) throw new Error("\u76EE\u5F55\u5F52\u5C5E\u65E0\u6CD5\u6838\u9A8C\uFF1B\u672A\u63A5\u7BA1\u6216\u8986\u76D6");
+  }
+}
+async function run(command, args, cwd, env = process.env) {
+  await new Promise((done, fail) => {
+    const child = spawn(command, args, { cwd, env, stdio: "inherit", detached: process.platform !== "win32" });
+    let interrupted = false;
+    let timer;
+    const kill = (signal) => {
+      if (!child.pid) return;
+      try {
+        process.kill(process.platform === "win32" ? child.pid : -child.pid, signal);
+      } catch {
+      }
+    };
+    const stop = () => {
+      interrupted = true;
+      kill("SIGTERM");
+      timer ??= setTimeout(() => kill("SIGKILL"), 3e3);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    const cleanup = () => {
+      clearTimeout(timer);
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+    };
+    child.once("error", (error) => {
+      cleanup();
+      fail(error);
+    });
+    child.once("close", (code) => {
+      cleanup();
+      code === 0 && !interrupted ? done() : fail(Object.assign(new Error("\u672C\u673A\u5B89\u88C5\u5B50\u8FDB\u7A0B\u5931\u8D25\u6216\u4E2D\u6B62\uFF0C\u4FDD\u7559\u539F\u9636\u6BB5\u4E0E\u5B9E\u4F8B"), { code: interrupted ? "INTERRUPTED" : `CHILD_${code}` }));
+    });
+  });
+}
+async function readInstallation(home, recordFile = "installation.json") {
+  let record;
+  try {
+    record = JSON.parse(await readFile4(join3(home, recordFile), "utf8"));
+  } catch (e) {
+    if (e.code === "ENOENT") return;
+    throw new Error("\u5B89\u88C5\u8BB0\u5F55\u65E0\u6CD5\u8BFB\u53D6\uFF0C\u672A\u91CD\u5EFA\u5B9E\u4F8B", { cause: e });
+  }
+  if (record.format !== 1 || record.home !== home || !record.stages || !["installing", "blocked", "failed", "prepared", "uninstalled", "ready"].includes(record.status)) throw new Error("\u5B89\u88C5\u683C\u5F0F\u4E0D\u517C\u5BB9\u6216\u76EE\u5F55\u7ED1\u5B9A\u53D8\u5316");
+  validateRelease(record.release);
+  if (record.releaseDigest !== digest(record.release)) throw new Error("\u5B89\u88C5\u53D1\u884C\u6458\u8981\u53D8\u5316\uFF0C\u505C\u6B62\u6062\u590D");
+  return record;
+}
+function installationPaths(home, release) {
+  const id = `${release.version}-${digest(release).slice(0, 16)}`;
+  const directory = join3(home, "releases", id);
+  const dependencyBundle = release.pythonDependencies.bundled ? `-${release.pythonDependencies.sha256.slice(0, 16)}` : "";
+  return {
+    directory,
+    runtime: join3(directory, "node_modules/@huohuo/research-agent"),
+    python: join3(home, "runtimes/python", release.python.sha256),
+    environment: join3(home, "environments", `${release.python.sha256.slice(0, 16)}-${release.requirementsSha256.slice(0, 16)}${dependencyBundle}`),
+    archive: join3(home, "cache", release.runtime.sha256 + ".tgz"),
+    pythonArchive: join3(home, "cache", release.python.sha256 + ".tgz")
+  };
+}
+function versionAtLeast(actual, minimum) {
+  const a = actual.split(".").map(Number), b = minimum.split(".").map(Number);
+  if ([...a, ...b].some((n) => !Number.isInteger(n))) return false;
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    if ((a[i] ?? 0) !== (b[i] ?? 0)) return (a[i] ?? 0) > (b[i] ?? 0);
+  }
+  return true;
+}
+async function install(home, candidate, hooks = {}, programsOnly = false) {
+  home = resolve3(home);
+  await mkdir3(home, { recursive: true, mode: 448 });
+  home = await realpath3(home);
+  return withLock(join3(home, "state/install.lock"), async () => {
+    if (!programsOnly) {
+      try {
+        await access(join3(home, "state/default-run.lock"));
+        throw new Error("\u5B9E\u4F8B\u4ECD\u6709\u8FD0\u884C\u9501\uFF1B\u5148\u6B63\u5E38\u505C\u6B62\u81EA\u5DF1\u7684\u5B9E\u4F8B\u518D\u4FEE\u590D\u7A0B\u5E8F");
+      } catch (e) {
+        if (e.code !== "ENOENT") throw e;
+      }
+    }
+    const recordFile = programsOnly ? "state/upgrade-target.json" : "installation.json";
+    const recordPath = join3(home, recordFile);
+    let record = await readInstallation(home, recordFile);
+    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 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");
+    }
+    record ??= { format: 1, release, releaseDigest: digest(release), home, status: "installing", stage: "preflight", stages: {} };
+    await atomicJSON(recordPath, record);
+    const paths = installationPaths(home, release);
+    const execute4 = hooks.run ?? run;
+    const sample = hooks.sample ?? sampleResources;
+    const cached = async (path, artifact2) => {
+      try {
+        await verifyArtifact(path, artifact2);
+        return true;
+      } catch (error) {
+        if (error.code === "ENOENT") return false;
+        throw error;
+      }
+    };
+    const installed = async () => {
+      try {
+        const owner = JSON.parse(await readFile4(join3(paths.python, ".huohuo-owner.json"), "utf8"));
+        await access(join3(paths.python, release.python.executable));
+        const python = owner.owner === release.python.sha256;
+        const root = join3(home, "instances/default");
+        const initialization = JSON.parse(await readFile4(join3(root, "initialization.json"), "utf8"));
+        const dependencies = JSON.parse(await readFile4(join3(paths.environment, ".dependencies-ready.json"), "utf8"));
+        const worker = JSON.parse(await readFile4(join3(root, "worker-install.json"), "utf8"));
+        const chat = JSON.parse(await readFile4(join3(root, "dsh/profiles/huohuo-chat/installed.json"), "utf8"));
+        for (const profile of ["huohuo-chat", "huohuo-worker", "huohuo-strategy-worker"]) await access(join3(root, "dsh/profiles", profile, "node_modules/@huohuo/research-agent/package.json"));
+        await access(join3(paths.runtime, "lib/distribution/managed.js"));
+        return { python, dependencies: initialization.package_sha256 === release.runtime.sha256 && initialization.status === "complete" && dependencies.sha256 === release.pythonDependencies.sha256 && worker.complete === true && chat.complete === true };
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+        try {
+          const owner = JSON.parse(await readFile4(join3(paths.python, ".huohuo-owner.json"), "utf8"));
+          await access(join3(paths.python, release.python.executable));
+          return { python: owner.owner === release.python.sha256, dependencies: false };
+        } catch {
+          return { python: false, dependencies: 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 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: 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 },
+        { path: join3(home, "instances/default"), bytes: 0 },
+        { path: paths.directory, bytes: inventory.dependencies ? 0 : release.pythonDependencies.expandedBytes },
+        { path: join3(home, "backups"), bytes: release.budget.backupBytes }
+      ];
+      const observation = await sample(costs.map((c) => c.path));
+      const dependencyPaths = [paths.directory, paths.environment, join3(home, "instances/default")];
+      const volumes = /* @__PURE__ */ new Set();
+      for (const path of dependencyPaths) {
+        const device = diskBudgets(observation, [{ path, bytes: 0 }], 0)[0].device;
+        if (!volumes.has(device)) {
+          volumes.add(device);
+          costs.push({ path, bytes: remainingDependencies });
+        }
+      }
+      const result = evaluateResources(observation, release.budget, costs, "install");
+      await atomicJSON(join3(home, "state/resources.json"), result);
+      if (result.status === "unknown" || result.status === "blocked") {
+        const details = result.reasons.map((reason) => `- ${reason}`).join("\n");
+        throw Object.assign(new Error(`\u706B\u706B\u6682\u65F6\u65E0\u6CD5\u7EE7\u7EED\u5B89\u88C5\u3002
+${details}
+\u5904\u7406\u540E\uFF0C\u91CD\u65B0\u8FD0\u884C\u521A\u624D\u7684\u5B89\u88C5\u547D\u4EE4\u3002`), { code: "RESOURCE_BLOCKED" });
+      }
+    };
+    const stage = async (name, action) => {
+      hooks.progress?.(name);
+      record.stage = name;
+      record.status = "installing";
+      const inputDigest = digest({ release: record.releaseDigest, stage: name });
+      const entry = { inputDigest, startedAt: (/* @__PURE__ */ new Date()).toISOString(), status: "running" };
+      record.stages[name] = entry;
+      await atomicJSON(recordPath, record);
+      try {
+        await check();
+        const output = await action();
+        entry.status = "verified";
+        entry.outputDigest = digest(output ?? null);
+        entry.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+      } catch (error) {
+        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";
+        await atomicJSON(recordPath, record);
+        throw error;
+      }
+      await atomicJSON(recordPath, record);
+    };
+    await stage("preflight", async () => {
+      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");
+      const probe = join3(home, `.write-probe-${randomUUID3()}`);
+      try {
+        await atomicJSON(probe, { probe: true });
+      } finally {
+        await rm2(probe, { force: true });
+      }
+    });
+    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);
+      return [release.runtime.sha256, release.python.sha256, release.pythonDependencies.sha256];
+    });
+    await stage("install-runtime", async () => {
+      try {
+        await access(paths.python);
+        const marker = JSON.parse(await readFile4(join3(paths.python, ".huohuo-owner.json"), "utf8"));
+        if (marker.owner !== release.python.sha256) throw new Error("\u53D7\u7BA1 Python \u5F52\u5C5E\u4E0D\u7B26");
+        await access(join3(paths.python, release.python.executable));
+        return release.python.sha256;
+      } catch (e) {
+        if (e.code !== "ENOENT") throw e;
+      }
+      await mkdir3(join3(home, "runtimes/python"), { recursive: true, mode: 448 });
+      const staging = `${paths.python}.${randomUUID3()}.staging`;
+      try {
+        await extractArchive(paths.pythonArchive, staging, release.python.expandedBytes);
+        await access(join3(staging, release.python.executable));
+        await atomicJSON(join3(staging, ".huohuo-owner.json"), { format: 1, owner: release.python.sha256 });
+        await rename3(staging, paths.python);
+      } finally {
+        await rm2(staging, { recursive: true, force: true });
+      }
+      return release.python.sha256;
+    });
+    await stage("install-dependencies", async () => {
+      await ownedDirectory(paths.directory, record.releaseDigest);
+      await atomicJSON(join3(paths.directory, "package.json"), {
+        name: "huohuo-managed-release",
+        private: true,
+        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);
+      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"));
+      if (createHash2("sha256").update(requirements).digest("hex") !== release.requirementsSha256) throw new Error("Python \u4F9D\u8D56\u9501\u6458\u8981\u4E0D\u7B26");
+      const assembly = await readFile4(join3(paths.runtime, "npm-shrinkwrap.json"));
+      if (createHash2("sha256").update(assembly).digest("hex") !== release.dsh.assemblySha256) throw new Error("DSH \u88C5\u914D\u9501\u6458\u8981\u4E0D\u7B26");
+      await ownedDirectory(paths.environment, `${release.python.sha256}:${release.requirementsSha256}`);
+      const python = join3(paths.environment, process.platform === "win32" ? "Scripts/python.exe" : "bin/python");
+      const wheels = join3(paths.directory, `wheels-${release.pythonDependencies.sha256}`);
+      try {
+        await access(join3(wheels, "requirements.txt"));
+      } catch (e) {
+        if (e.code !== "ENOENT") throw e;
+        const staging = `${wheels}.${randomUUID3()}.staging`;
+        try {
+          await extractArchive(join3(home, "cache", release.pythonDependencies.sha256 + ".tgz"), staging, release.pythonDependencies.expandedBytes);
+          await access(join3(staging, "requirements.txt"));
+          await rename3(staging, wheels);
+        } finally {
+          await rm2(staging, { recursive: true, force: true });
+        }
+      }
+      let environmentReady = false;
+      try {
+        const ready = JSON.parse(await readFile4(join3(paths.environment, ".dependencies-ready.json"), "utf8"));
+        if (ready.sha256 !== release.pythonDependencies.sha256) throw new Error("\u5DF2\u6709\u73AF\u5883\u7ED1\u5B9A\u4E0D\u540C wheel \u4EA7\u7269\uFF1B\u4E0D\u80FD\u539F\u4F4D\u6539\u5199\u5171\u4EAB\u73AF\u5883");
+        await access(python);
+        environmentReady = true;
+      } catch (e) {
+        if (e.code !== "ENOENT") throw e;
+      }
+      if (!environmentReady) {
+        await execute4(join3(paths.python, release.python.executable), ["-m", "venv", paths.environment], home);
+        await execute4(python, [
+          "-m",
+          "pip",
+          "--isolated",
+          "install",
+          "--no-index",
+          "--find-links",
+          wheels,
+          "--require-hashes",
+          "--only-binary=:all:",
+          ...release.pythonDependencies.bundled ? ["--no-cache-dir"] : [],
+          "-r",
+          join3(wheels, "requirements.txt")
+        ], home);
+      }
+      await execute4(python, ["-m", "pip", "--isolated", "check"], home);
+      await atomicJSON(join3(paths.environment, ".dependencies-ready.json"), { sha256: release.pythonDependencies.sha256 });
+      return { python, runtime: release.runtime.sha256 };
+    });
+    if (programsOnly) {
+      record.status = "prepared";
+      record.stage = "prepared";
+      await atomicJSON(recordPath, record);
+      return record;
+    }
+    await stage("assemble-profiles", async () => {
+      await execute4(process.execPath, [join3(paths.runtime, "lib/distribution/managed.js"), "prepare", home], home);
+      return { release: record.releaseDigest };
+    });
+    await stage("verify", async () => {
+      await execute4(process.execPath, [join3(paths.runtime, "lib/distribution/managed.js"), "verify-live", home], home);
+      return { release: record.releaseDigest };
+    });
+    record.status = "ready";
+    record.stage = "ready";
+    await atomicJSON(recordPath, record);
+    return record;
+  });
+}
+
+// distribution/bootstrap/control.ts
+import { createServer, request as httpRequest } from "node:http";
+import { readFile as readFile5, rm as rm3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+var execute3 = promisify4(execFile4);
+async function control(home, releaseDigest, command) {
+  let binding;
+  try {
+    binding = JSON.parse(await readFile5(join4(home, "state/default-control.json"), "utf8"));
+  } catch (e) {
+    if (e.code === "ENOENT") return false;
+    throw new Error("\u672C\u673A\u8FD0\u884C\u8BB0\u5F55\u65E0\u6CD5\u6838\u9A8C");
+  }
+  if (binding.format !== 1 || binding.home !== home || binding.releaseDigest !== releaseDigest || !/^[A-Za-z0-9_-]{43}$/.test(binding.token) || typeof binding.runOwner !== "string" || !/^[a-f0-9-]{36}$/.test(binding.runOwner) || !Number.isInteger(binding.port) || binding.port < 1024 || binding.port > 65535) throw new Error("\u672C\u673A\u8FD0\u884C\u7ED1\u5B9A\u65E0\u6548\uFF1B\u672A\u64CD\u4F5C\u4EFB\u4F55\u8FDB\u7A0B");
+  try {
+    await new Promise((done, fail) => {
+      const req = httpRequest({
+        hostname: "127.0.0.1",
+        port: binding.port,
+        path: `/${command}`,
+        method: "POST",
+        headers: { Authorization: `Bearer ${binding.token}`, Connection: "close" },
+        timeout: 3e3
+      }, (res) => {
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk;
+          if (body.length > 8192) req.destroy(new Error("\u672C\u673A\u63A7\u5236\u54CD\u5E94\u8D85\u9650"));
+        });
+        res.once("end", () => {
+          try {
+            const result = JSON.parse(body);
+            if (res.statusCode !== 200 || result.home !== home || result.releaseDigest !== releaseDigest) throw new Error();
+            done();
+          } catch {
+            fail(new Error("\u672C\u673A\u63A7\u5236\u8EAB\u4EFD\u6216\u54CD\u5E94\u672A\u901A\u8FC7\uFF1B\u672A\u63A5\u7BA1\u8FDB\u7A0B"));
+          }
+        });
+      });
+      req.once("timeout", () => req.destroy(new Error("\u672C\u673A\u63A7\u5236\u5165\u53E3\u65E0\u54CD\u5E94\uFF1B\u8BF7\u8FD0\u884C doctor \u6838\u5BF9\u539F\u7EC8\u7AEF")));
+      req.once("error", fail);
+      req.end();
+    });
+  } catch (error) {
+    if (error.code === "ECONNREFUSED" && await isLockOwnerDead(join4(home, "state/default-run.lock"), binding.runOwner)) return false;
+    throw error;
+  }
+  return true;
+}
+
+// distribution/bootstrap/maintenance.ts
+import { access as access2, readFile as readFile6, readdir as readdir2, lstat as lstat2, rename as rename4, rm as rm4, realpath as realpath4 } from "node:fs/promises";
+import { join as join5, resolve as resolve4 } from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+async function upgradeJournal(home) {
+  try {
+    const value = JSON.parse(await readFile6(join5(home, "state/upgrade.json"), "utf8"));
+    if (value.format !== 1 || !/^[a-f0-9]{64}$/.test(value.from) || !/^[a-f0-9]{64}$/.test(value.to) || !["stopping", "backed-up", "schema-unchanged", "profiles", "migrated", "verified", "complete"].includes(value.stage) || !value.backup.startsWith(join5(home, "backups") + "/")) throw new Error("\u5347\u7EA7\u8BB0\u5F55\u65E0\u6548");
+    return value;
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+}
+function assertCompatibleUpgrade(previous, next) {
+  if (previous.schema.minimum !== next.schema.minimum || previous.schema.maximum !== next.schema.maximum || previous.dsh.version !== next.dsh.version) {
+    throw new Error("\u6570\u636E\u6216 DSH \u4F1A\u8BDD\u8FC1\u79FB\u8D85\u51FA\u5DF2\u9A8C\u8BC1\u8303\u56F4\uFF1B\u672A\u505C\u6B62\u539F\u5B9E\u4F8B\u6216\u8986\u76D6\u65B0\u6570\u636E");
+  }
+  const oldFiles = Object.keys(previous.schema.files).sort(), added = Object.keys(next.schema.files).filter((name) => !(name in previous.schema.files)).sort();
+  if (oldFiles.some((name) => next.schema.files[name] !== previous.schema.files[name]) || added.some((name) => name <= oldFiles.at(-1)) || previous.schema.migrationsSha256 !== next.schema.migrationsSha256 && !added.length) throw new Error("\u8FC1\u79FB\u4E0D\u662F\u5DF2\u5B9A\u4E49\u7684\u4E0D\u53EF\u53D8\u524D\u7F00\u8FFD\u52A0\uFF1B\u672A\u5207\u6362\u6570\u636E\u6216\u7A0B\u5E8F");
+  const before = previous.version.split("-")[0].split(".").map(Number), after = next.version.split("-")[0].split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (after[i] > before[i]) return;
+    if (after[i] < before[i]) throw new Error("upgrade \u4E0D\u6267\u884C\u7248\u672C\u964D\u7EA7\uFF1B\u9700\u8981\u660E\u786E\u7684\u517C\u5BB9\u56DE\u9000\u65B9\u6848");
+  }
+  if (!previous.version.includes("-") && next.version.includes("-")) throw new Error("\u4E0D\u81EA\u52A8\u4ECE\u7A33\u5B9A\u7248\u672C\u5207\u6362\u5230\u9884\u53D1\u5E03");
+}
+async function stopOwned(home, releaseDigest) {
+  if (!await control(home, releaseDigest, "stop")) return;
+  for (let i = 0; i < 100; i++) {
+    try {
+      await access2(join5(home, "state/default-run.lock"));
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    await delay(100);
+  }
+  throw new Error("\u539F\u5B9E\u4F8B\u5C1A\u672A\u786E\u8BA4\u9000\u51FA\uFF1B\u672A\u5E76\u884C\u542F\u52A8\u3001\u672A\u5F3A\u5236\u6740\u8FDB\u7A0B");
+}
+async function backupBytes(directory) {
+  let bytes = 1024 * 1024;
+  async function visit(path) {
+    for (const item of await readdir2(path, { withFileTypes: true })) {
+      if (["node_modules", "cache", "python", "__pycache__"].includes(item.name)) continue;
+      if (item.isSymbolicLink()) throw new Error("\u5907\u4EFD\u4E0D\u63A5\u7BA1\u672A\u77E5\u7684\u5B9E\u4F8B\u94FE\u63A5");
+      if (item.isDirectory()) await visit(join5(path, item.name));
+      else {
+        const info = await lstat2(join5(path, item.name));
+        bytes += info.size + 512;
+      }
+    }
+  }
+  await visit(directory);
+  if (!Number.isSafeInteger(bytes)) throw new Error("\u5907\u4EFD\u9884\u7B97\u8D85\u51FA\u5DF2\u652F\u6301\u8303\u56F4");
+  return bytes;
+}
+async function upgrade(home, candidate, hooks = {}) {
+  home = await realpath4(resolve4(home));
+  const next = validateRelease(candidate);
+  let current = await readInstallation(home);
+  if (!current || current.status !== "ready") throw new Error("\u5148\u4FEE\u590D\u5F53\u524D\u5B89\u88C5\uFF0C\u4E0D\u80FD\u5728\u4E0D\u5B8C\u6574\u5B9E\u4F8B\u4E0A\u5347\u7EA7");
+  let journal = await upgradeJournal(home);
+  if (journal && journal.stage !== "complete" && journal.to !== digest(next)) throw new Error("\u5B58\u5728\u672A\u5B8C\u6210\u5347\u7EA7\uFF1B\u5FC5\u987B\u5148\u7EE7\u7EED\u539F\u56FA\u5B9A\u76EE\u6807");
+  if (current.releaseDigest === digest(next)) {
+    if (journal && journal.to === current.releaseDigest && journal.stage !== "complete") {
+      await (hooks.run ?? run)(process.execPath, [join5(installationPaths(home, next).runtime, "lib/distribution/managed.js"), "verify-live", home], home);
+      journal.stage = "complete";
+      await atomicJSON(join5(home, "state/upgrade.json"), journal);
+    }
+    hooks.progress?.("\u5DF2\u7ECF\u662F\u540C\u4E00\u53D1\u884C\uFF0C\u65E0\u9700\u8FC1\u79FB");
+    return;
+  }
+  assertCompatibleUpgrade(current.release, next);
+  if (journal?.stage === "complete") {
+    await withLock(join5(home, "state/install.lock"), async () => {
+      await rename4(join5(home, "state/upgrade.json"), join5(home, `state/upgrade-${randomUUID4()}.json`));
+      try {
+        await rename4(join5(home, "state/upgrade-target.json"), join5(home, `state/upgrade-target-${randomUUID4()}.json`));
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    });
+    journal = void 0;
+  }
+  const target = await install(home, next, hooks, true);
+  if (target.releaseDigest !== digest(next)) throw new Error("\u5347\u7EA7\u6062\u590D\u76EE\u6807\u4E0E\u8BF7\u6C42\u4E0D\u540C\uFF1B\u4FDD\u7559\u539F\u56FA\u5B9A\u76EE\u6807");
+  const execute4 = hooks.run ?? run;
+  await withLock(join5(home, "state/install.lock"), async () => {
+    current = await readInstallation(home);
+    if (journal && journal.from !== current.releaseDigest) throw new Error("\u5347\u7EA7\u671F\u95F4\u539F\u53D1\u884C\u7ED1\u5B9A\u53D8\u5316\uFF1B\u8BF7\u5148\u5BF9\u8D26");
+    journal ??= {
+      format: 1,
+      from: current.releaseDigest,
+      to: target.releaseDigest,
+      backup: join5(home, "backups", `upgrade-${target.releaseDigest.slice(0, 16)}-${randomUUID4()}`),
+      stage: "stopping"
+    };
+    await atomicJSON(join5(home, "state/upgrade.json"), journal);
+    await stopOwned(home, current.releaseDigest);
+    const releaseRun = await acquireLock(join5(home, "state/default-run.lock"));
+    try {
+      const bytes = await backupBytes(join5(home, "instances/default"));
+      const result = evaluateResources(
+        await (hooks.sample ?? sampleResources)([join5(home, "backups")]),
+        target.release.budget,
+        [{ path: join5(home, "backups"), bytes }],
+        "install"
+      );
+      if (result.status === "unknown" || result.status === "blocked") throw new Error("\u4E00\u81F4\u6027\u5907\u4EFD\u8D44\u6E90\u4E0D\u8DB3\uFF1B\u539F\u6570\u636E\u4FDD\u7559");
+      if (journal.stage === "stopping") {
+        await execute4(process.execPath, [join5(installationPaths(home, current.release).runtime, "lib/distribution/managed.js"), "backup", home], home);
+        journal.stage = "backed-up";
+        await atomicJSON(join5(home, "state/upgrade.json"), journal);
+      }
+      const runtime = installationPaths(home, target.release).runtime;
+      await execute4(process.execPath, [join5(runtime, "lib/distribution/managed.js"), "prepare-upgrade", home], home);
+      journal.stage = "profiles";
+      await atomicJSON(join5(home, "state/upgrade.json"), journal);
+      if (current.release.schema.migrationsSha256 !== target.release.schema.migrationsSha256) {
+        const space = evaluateResources(
+          await (hooks.sample ?? sampleResources)([join5(home, "instances/default")]),
+          target.release.budget,
+          [{ path: join5(home, "instances/default"), bytes: bytes + target.release.budget.installTemporaryBytes }],
+          "install"
+        );
+        if (space.status === "blocked" || space.status === "unknown") throw new Error("\u8FC1\u79FB\u524D\u8D44\u6E90\u4E0D\u8DB3\uFF1B\u4FDD\u7559\u5347\u7EA7\u65E5\u5FD7\u548C\u5F53\u524D\u6570\u636E");
+        await execute4(process.execPath, [join5(runtime, "lib/distribution/managed.js"), "migrate-upgrade", home], home);
+      }
+      journal.stage = "migrated";
+      await atomicJSON(join5(home, "state/upgrade.json"), journal);
+      await execute4(process.execPath, [join5(runtime, "lib/distribution/managed.js"), "verify-upgrade", home], home);
+      journal.stage = "verified";
+      await atomicJSON(join5(home, "state/upgrade.json"), journal);
+      target.status = "ready";
+      target.stage = "ready";
+      await atomicJSON(join5(home, "installation.json"), target);
+      journal.stage = "complete";
+      await atomicJSON(join5(home, "state/upgrade.json"), journal);
+      hooks.progress?.("\u5347\u7EA7\u9A8C\u8BC1\u901A\u8FC7\uFF0C\u5DF2\u5207\u6362\u53D1\u884C\u7ED1\u5B9A\uFF1B\u5907\u4EFD\u4FDD\u7559");
+    } finally {
+      await releaseRun();
+    }
+  });
+}
+async function removeOwned(path, expected) {
+  try {
+    const marker = JSON.parse(await readFile6(join5(path, ".huohuo-owner.json"), "utf8"));
+    if (marker.format !== 1 || marker.owner !== expected) throw new Error("\u53D7\u7BA1\u76EE\u5F55\u5F52\u5C5E\u4E0D\u7B26\uFF0C\u672A\u5220\u9664");
+    await rm4(path, { recursive: true });
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+async function uninstall(home, hooks = {}) {
+  home = await realpath4(resolve4(home));
+  await withLock(join5(home, "state/install.lock"), async () => {
+    const current = await readInstallation(home);
+    if (!current) throw new Error("\u6CA1\u6709\u53EF\u6838\u9A8C\u7684\u6301\u4E45\u5B89\u88C5");
+    const journal = await upgradeJournal(home);
+    if (journal && journal.stage !== "complete") throw new Error("\u5347\u7EA7\u5C1A\u672A\u5BF9\u8D26\uFF0C\u4E0D\u80FD\u5378\u8F7D\u7A0B\u5E8F");
+    await stopOwned(home, current.releaseDigest);
+    const releaseRun = await acquireLock(join5(home, "state/default-run.lock"));
+    try {
+      const paths = installationPaths(home, current.release);
+      if ((await readdir2(join5(home, "instances"))).some((name) => name !== "default")) throw new Error("\u68C0\u6D4B\u5230\u5176\u4ED6\u5B9E\u4F8B\uFF1B\u5171\u4EAB\u8FD0\u884C\u73AF\u5883\u5F52\u5C5E\u9700\u5148\u6838\u67E5\uFF0C\u672A\u5220\u9664");
+      if (current.status !== "uninstalled") {
+        await (hooks.run ?? run)(process.execPath, [join5(paths.runtime, "lib/distribution/managed.js"), "uninstall-programs", home], home);
+        current.status = "uninstalled";
+        current.stage = "uninstalled";
+        await atomicJSON(join5(home, "installation.json"), current);
+      }
+      await removeOwned(paths.directory, current.releaseDigest);
+      await removeOwned(paths.environment, `${current.release.python.sha256}:${current.release.requirementsSha256}`);
+      if (!(await readdir2(join5(home, "releases"))).length) await removeOwned(paths.python, current.release.python.sha256);
+      hooks.progress?.(`\u5DF2\u5378\u8F7D\u53EF\u518D\u751F\u6210\u7A0B\u5E8F\uFF1B\u5B9E\u4F8B\u3001\u51ED\u636E\u3001\u4F1A\u8BDD\u548C\u5907\u4EFD\u4FDD\u7559\u5728 ${home}`);
+    } finally {
+      await releaseRun();
+    }
+  });
+}
+
+// distribution/bootstrap/entry.ts
+function artifactSource(source, directory) {
+  return async (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 })));
+  };
+}
+async function main(args = process.argv.slice(2)) {
+  let home = join6(homedir(), ".huohuo"), noOpen = false, command = "start";
+  let releaseFile, artifactDirectory;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--home") {
+      if (!args[i + 1]) throw new Error("--home \u9700\u8981\u76EE\u5F55");
+      home = resolve5(args[++i]);
+    } else if (args[i] === "--release" || args[i] === "--artifacts") {
+      const option = args[i];
+      if (!args[i + 1]) throw new Error(`${option} \u9700\u8981\u672C\u673A\u8DEF\u5F84`);
+      if (option === "--release") releaseFile = resolve5(args[++i]);
+      else artifactDirectory = resolve5(args[++i]);
+    } else if (args[i] === "--no-open") noOpen = true;
+    else if (args[i] === "--version") {
+      const packageFile = join6(dirname5(fileURLToPath(import.meta.url)), "package.json");
+      const manifest = JSON.parse(await readFile7(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]");
+  }
+  try {
+    home = await realpath5(home);
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  let record = await readInstallation(home);
+  const labels = {
+    preflight: "\u68C0\u67E5\u672C\u673A\u73AF\u5883",
+    download: "\u4E0B\u8F7D\u56FA\u5B9A\u53D1\u884C\u8D44\u6E90",
+    "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"
+  };
+  const progress = (stage) => console.log(`\u706B\u706B\uFF1A${labels[stage] ?? stage}`);
+  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 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);
+    return;
+  }
+  if (command === "uninstall") {
+    await uninstall(home, { progress });
+    return;
+  }
+  if (command === "stop") {
+    if (!record || !await control(home, record.releaseDigest, "stop")) throw new Error("\u6CA1\u6709\u53EF\u6838\u9A8C\u7684\u672C\u673A\u8FD0\u884C\u63A7\u5236\u5165\u53E3\uFF1B\u672A\u5411\u4EFB\u4F55 PID \u53D1\u9001\u4FE1\u53F7");
+    console.log("\u5DF2\u8BF7\u6C42\u539F\u7EC8\u7AEF\u6B63\u5E38\u505C\u6B62\u672C\u5B9E\u4F8B");
+    return;
+  }
+  if (command === "doctor") {
+    if (!record) {
+      console.log(JSON.stringify({ status: "unknown", reason: "\u5C1A\u65E0\u6301\u4E45\u5B89\u88C5", home }));
+      return;
+    }
+    const paths = installationPaths(home, record.release);
+    const targets = [home, paths.directory, paths.environment, join6(home, "instances/default")];
+    const resources = evaluateResources(await sampleResources(targets), record.release.budget, targets.map((path) => ({ path, bytes: 0 })), "start");
+    console.log(JSON.stringify({
+      home,
+      version: record.release.version,
+      installation: record.status,
+      stage: record.stage,
+      upgrade: await upgradeJournal(home),
+      resources
+    }, null, 2));
+    return;
+  }
+  const pending = await upgradeJournal(home);
+  if (pending && pending.stage !== "complete") throw new Error("\u5347\u7EA7\u5C1A\u672A\u5BF9\u8D26\uFF1B\u8BF7\u7EE7\u7EED\u540C\u4E00\u56FA\u5B9A\u53D1\u884C\u7684 upgrade\uFF0C\u4E0D\u4F1A\u81EA\u52A8\u5207\u56DE\u65E7\u7A0B\u5E8F\u6216\u8986\u76D6\u65B0\u6570\u636E");
+  if (record?.status === "ready") {
+    if (await control(home, record.releaseDigest, noOpen ? "status" : "open")) {
+      console.log(noOpen ? "\u5F53\u524D\u5B9E\u4F8B\u5DF2\u5728\u8FD0\u884C" : "\u5DF2\u8BF7\u6C42\u5F53\u524D\u5B9E\u4F8B\u6253\u5F00\u8BA4\u8BC1\u9875\u9762");
+      return;
+    }
+    const runtime = installationPaths(home, record.release).runtime;
+    try {
+      await readFile7(join6(runtime, "lib/distribution/managed.js"));
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+      record = void 0;
+    }
+  }
+  if (!record || record.status !== "ready") {
+    let catalog = null;
+    if (!record) {
+      try {
+        catalog = JSON.parse(await readFile7(releaseFile ?? join6(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 installedHome = record.home;
+  await run(process.execPath, [join6(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;
+  });
+}
+export {
+  main
+};

package/package.json

@@ -1,6 +1,22 @@
 {
   "name": "@pab-iprg/huohuo",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0-preview.2",
+  "type": "module",
+  "description": "火火投研伙伴安装入口",
+  "bin": {
+    "huohuo": "./cli.js"
+  },
+  "engines": {
+    "node": ">=24.8.0"
+  },
+  "files": [
+    "cli.js",
+    "release.json",
+    "README.md",
+    "assets"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  }
+}

package/release.json

@@ -0,0 +1,93 @@
+{
+  "format": 1,
+  "bootstrapFormat": 1,
+  "version": "1.0.0",
+  "nodeMajor": 24,
+  "npmMajor": 11,
+  "qualification": "qualified",
+  "platform": {
+    "os": "darwin",
+    "arch": "arm64",
+    "minimumOsRelease": "25.6.0"
+  },
+  "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,
+    "bundled": true
+  },
+  "python": {
+    "url": "https://github.com/astral-sh/python-build-standalone/releases/download/20261026/cpython-3.13.18%2B20261026-aarch64-apple-darwin-install_only_stripped.tar.gz",
+    "sha256": "8392b6ea51d94391befb2c31ebe75463f045d0b69dfcf5e1bb3234e1f5fa3405",
+    "downloadBytes": 25265774,
+    "expandedBytes": 66020864,
+    "redirectHosts": [
+      "release-assets.githubusercontent.com"
+    ],
+    "executable": "python/bin/python3",
+    "build": "cpython-3.13.18+20261026-aarch64-apple-darwin-install_only_stripped.tar.gz",
+    "license": "python/lib/python3.13/LICENSE.txt"
+  },
+  "pythonDependencies": {
+    "url": "https://bundled.invalid/4f008fe4491617729554e056ad59eee686ccc5d95c9f1d5259da705bf054ce21.tgz",
+    "sha256": "4f008fe4491617729554e056ad59eee686ccc5d95c9f1d5259da705bf054ce21",
+    "downloadBytes": 10235,
+    "expandedBytes": 15007,
+    "bundled": true
+  },
+  "dsh": {
+    "version": "0.2.1-rc.2",
+    "assemblySha256": "08cf11de70e49981b4891c0aaa2a5e7b872a95b6aa07557bb629713fa8f9e249"
+  },
+  "requirementsSha256": "57042fff45cee66fe33712472e2e5b88f03a084068ca20242588b2e18b3e167b",
+  "profilesSha256": "bdd628f3a599a69a9835db9904fb55d36c57e0b3486b4f3f7dbec8d8a47f36f0",
+  "budget": {
+    "minimumEffectiveMemoryBytes": 34359738368,
+    "startupHeadroomBytes": 134217728,
+    "heavyJobHeadroomBytes": 1073741824,
+    "diskReserveBytes": 1073741824,
+    "recoverySamples": 3,
+    "processTreeBudgetBytes": 17179869184,
+    "sampleIntervalMs": 2000,
+    "sampleMaxAgeMs": 10000,
+    "installTemporaryBytes": 1073741824,
+    "dependenciesBytes": 4294967296,
+    "backupBytes": 0
+  },
+  "schema": {
+    "minimum": 1,
+    "maximum": 1,
+    "migrationsSha256": "ba029fdbffa5320e61393b484d08accafce60e9aa8dacde5b6212fb79dd9146b",
+    "files": {
+      "001_init.sql": "b42b6192d872f0f65cfbbf9d0c7fb442d3aa49584a6cf321d3bcc641b31b70da",
+      "002_contact_decision.sql": "af82cb9975a09fa09c0f970b70d04a7b55a960d72e0853f4573d571efaa46f0a",
+      "003_schedules.sql": "2937f7be2693ce9b410ee9a73bd10c5e819c5081a10a6b3993c33f37ad42295f",
+      "004_condition_state.sql": "f081d250dd525ad57a450bd6bca59a75f8fb1428177d670ae9fa142ed79721d6",
+      "005_execution_handoff.sql": "ebf2e5c4890b7a73ae1ffb57a70bb15183f48a6c1fa2acf3a48b95ccb3d992b3",
+      "006_entity_confirmation.sql": "d25ee376e7f6dd55df2edeb68d7591ef5fbaa34eeb3eef662cd76e183526d3c0",
+      "007_research_tool_calls.sql": "df9c7d8d25b44b151f743e2d5167b34ae89c64e67423d8af554364fd792da942",
+      "008_followup_notifications.sql": "98865d811879afd679846087a5f01ee2db371dcb90381a9c400c940a5c1c4b37",
+      "008_investment.sql": "71cecf6215552c725797059efdcb501247e1225c7d9f662de606266d3a947e61",
+      "009_notification_channels.sql": "572424d739203a8514ae59920a0ad69cf83f278479b48d48becb88bddda25d9a",
+      "010_strategies.sql": "af023fab201db6bd2e15e2348125d112bc21cf3a59d8afd0a2d616fc05cee209",
+      "011_strategy_run_subjects.sql": "53a1c216ed775a06549dcc201f9494ceabe308bee6dc52a214b685cca2f2fe8d",
+      "012_strategy_schedule.sql": "ccddd81bb70d2c86356e6f1ad09132e7397837d17e926b515c8e281a362bdd58",
+      "014_industry_chain.sql": "b656efffe746d14ca350ea1c9ecfcce2d98b5753e4b2f862c75d0456a062fd4a",
+      "015_source_heads.sql": "652bf637892edbbe969ce5ed4ce45a4a0c43d03de395fce1b828fc4c0169f885",
+      "016_legacy_transfer.sql": "b6e3c214b103487d741226b0f83525e0cacbb0c440bd1935d0e963dc9b9bfd07",
+      "017_unified_strategy_work.sql": "8d055ca58f3e73482fb16c630c733ae93197244b37e4509cc90c7dec3bf88d60",
+      "018_personalization.sql": "7f62a4eb74707fb071f56d6057b6d6517ed7648af23ebe290f3be15d260a103c",
+      "019_position_risk.sql": "3c461fa435b352127fd4ee4e7ed3de2c924561a3727dce1535d7d3a47c436ca9",
+      "020_notification_tests.sql": "3eb0d72eadf04b074208dbe0ef6a72ee614ec11a15143108a2471568b7b4fb22",
+      "021_notification_priority.sql": "f742b4c4b796e918bfc6a08bac8c5ae206382075925acf7b1c430b033f5177e6",
+      "022_research_job_priority.sql": "fcb0c0af025806faab7cd403097a9d2c55e07331ab0a78b2926c1927a87f4ed4",
+      "023_adaptive_notifications.sql": "80630e2dad73844d48b265fbc33648b01d8321a6fd9a0587ef4dc01f362aadec",
+      "023_notification_attention.sql": "5dd85fb001192558211c7b69e3452984c52119f215750ed6283b296d3dccc842",
+      "024_t_trade_watch.sql": "aa38470ddab00e0cbca07ce6d5cc31399ba2b6e40c8d8d888e88ec093a9f89ef"
+    }
+  }
+}