@morlay/dsh-desktop-shell 0.2.4 → 0.2.6

package/src/__tests__/host-process.spec.ts

@@ -0,0 +1,205 @@
+import { EventEmitter } from "node:events";
+import { join } from "node:path";
+import { PassThrough } from "node:stream";
+import type { ChildProcess } from "node:child_process";
+import { describe, expect, it, vi } from "vitest";
+import { DESKTOP_HOST_PROTOCOL_VERSION } from "@morlay/dsh-desktop-host/wire";
+import { DesktopHostProcess, type DesktopHostOptions } from "../host-process.ts";
+
+interface SpawnCall {
+  readonly command: string;
+  readonly args: readonly string[];
+  readonly cwd: string | undefined;
+  readonly stdio: unknown;
+}
+
+interface FakeChild extends ChildProcess {
+  readonly sent: unknown[];
+  readonly requestPipe: PassThrough;
+  readonly responsePipe: PassThrough;
+}
+
+function fakeChild(): FakeChild {
+  const child = new EventEmitter() as FakeChild;
+  const requestPipe = new PassThrough();
+  const responsePipe = new PassThrough();
+  Object.assign(child, {
+    sent: [] as unknown[],
+    requestPipe,
+    responsePipe,
+    stderr: new PassThrough(),
+    stdout: new PassThrough(),
+    connected: true,
+    kill: () => true,
+    send: (message: unknown, callback?: (error: Error | null) => void) => {
+      child.sent.push(message);
+      callback?.(null);
+      return true;
+    },
+  });
+  Object.assign(child, {
+    stdio: [null, null, null, requestPipe, responsePipe, null],
+  });
+  return child;
+}
+
+function harness(options: Partial<DesktopHostOptions> = {}, inspectPort?: number) {
+  const calls: SpawnCall[] = [];
+  const child = fakeChild();
+  const host = new DesktopHostProcess(
+    "/runtime/node/node",
+    "/app/seed",
+    "/home/profiles/desktop",
+    inspectPort,
+    {
+      entry: ENTRY,
+      ...options,
+      spawn: ((command: string, args: readonly string[], spawnOptions: { cwd?: string }) => {
+        calls.push({
+          command,
+          args,
+          cwd: spawnOptions.cwd,
+          stdio: (spawnOptions as { stdio?: unknown }).stdio,
+        });
+        return child;
+      }) as never,
+    },
+  );
+  return { calls, child, host };
+}
+
+// 宿主入口是**源码**（包的 `exports` 指 `src/index.ts`），由 `--import` 的 TS loader 转译：
+// 两种形态（dev / bundle）同一条路，部署里不再落 dist 载荷。
+const ENTRY = join("/app/seed", "node_modules", "@morlay", "dsh-desktop-host", "src", "index.ts");
+
+function ready(child: FakeChild): void {
+  child.emit("message", {
+    type: "ready",
+    protocolVersion: DESKTOP_HOST_PROTOCOL_VERSION,
+    origin: "http://127.0.0.1:3000",
+  });
+}
+
+// 从请求管道读到至少 count 条完整帧（帧写入跨 tick）。
+describe("桌面 host 子进程", () => {
+  it("启动形态：入口路径、argv 顺序与 stdio", async () => {
+    const { calls, child, host } = harness(
+      {
+        packageManager: { pnpm: "/app/runtime/pnpm/bin/pnpm.mjs", nodeBin: "/app/runtime/bin" },
+        nodeArgs: ["--import=/app/runtime/loader/register.mjs"],
+      },
+      9230,
+    );
+    const started = host.start();
+    expect(calls).toHaveLength(1);
+    const call = calls[0];
+    expect(call?.command).toBe("/runtime/node/node");
+    expect(call?.stdio).toEqual(["ignore", "pipe", "pipe", "ipc"]);
+    expect(call?.cwd).toBe("/home/profiles/desktop");
+    expect(call?.args.slice(0, 3)).toEqual([
+      "--expose-internals",
+      "--inspect=127.0.0.1:9230",
+      "--import=/app/runtime/loader/register.mjs",
+    ]);
+    expect(call?.args.slice(3)).toEqual([
+      ENTRY,
+      "--profile-dir",
+      "/home/profiles/desktop",
+      "--runtime-dir",
+      "/app/seed",
+      "--pnpm",
+      "/app/runtime/pnpm/bin/pnpm.mjs",
+      "--node-bin",
+      "/app/runtime/bin",
+    ]);
+    ready(child);
+    await expect(started).resolves.toEqual({
+      protocolVersion: DESKTOP_HOST_PROTOCOL_VERSION,
+      origin: "http://127.0.0.1:3000",
+    });
+    const stopped = host.stop();
+    child.emit("close", 0);
+    await stopped;
+  });
+
+  it("processTitle 转成 node --title，进程在 ps 里可区分", async () => {
+    const { calls, child, host } = harness({ processTitle: "dsh-custom-next-server" });
+    const started = host.start();
+    expect(calls[0]?.args.slice(0, 2)).toEqual([
+      "--expose-internals",
+      "--title=dsh-custom-next-server",
+    ]);
+    ready(child);
+    await started;
+    const stopped = host.stop();
+    child.emit("close", 0);
+    await stopped;
+  });
+
+  it("ready 之前报 fatal 时启动失败", async () => {
+    const { child, host } = harness();
+    const started = host.start();
+    child.emit("message", { type: "fatal", message: "composition exploded" });
+    await expect(started).rejects.toThrow("composition exploded");
+  });
+
+  // fatal 可另带完整诊断（util.inspect 的错误，含 code/syscall/path/cause）。壳的 dialog 只显示
+  // message，完整诊断走 stderr——IPC 与 stderr 谁先到不确定，诊断不能只挂在一边。
+  it("fatal 带完整诊断时写进 stderr，失败信息仍是 message", async () => {
+    const written = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+    try {
+      const { child, host } = harness();
+      const started = host.start();
+      child.emit("message", {
+        type: "fatal",
+        message: "composition exploded",
+        diagnostic: "Error: composition exploded\n    at boot (/app/seed/index.mjs:12:3)",
+      });
+      await expect(started).rejects.toThrow("composition exploded");
+      expect(written.mock.calls.map((call) => String(call[0])).join("")).toContain(
+        "at boot (/app/seed/index.mjs:12:3)",
+      );
+    } finally {
+      written.mockRestore();
+    }
+  });
+
+  it("调试端点命令走 IPC，端点状态回调给订阅者", async () => {
+    const { child, host } = harness();
+    const started = host.start();
+    ready(child);
+    await started;
+
+    const states: unknown[] = [];
+    const release = host.onInspected((state) => states.push(state));
+    host.inspect(0);
+    host.endInspect();
+    expect(child.sent).toEqual([{ type: "inspect", port: 0 }, { type: "inspect-off" }]);
+
+    child.emit("message", { type: "inspected", url: "ws://127.0.0.1:9229/uuid" });
+    child.emit("message", { type: "inspected", url: null, message: "listen failed" });
+    expect(states).toEqual([
+      { type: "inspected", url: "ws://127.0.0.1:9229/uuid" },
+      { type: "inspected", url: null, message: "listen failed" },
+    ]);
+
+    release();
+    child.emit("message", { type: "inspected", url: null });
+    expect(states).toHaveLength(2);
+
+    const stopped = host.stop();
+    child.emit("close", 0);
+    await stopped;
+  });
+
+  it("stop 通过 IPC 请求收尾", async () => {
+    const { child, host } = harness();
+    const started = host.start();
+    ready(child);
+    await started;
+    const stopped = host.stop();
+    child.emit("close", 0);
+    await stopped;
+    expect(child.sent).toEqual([{ type: "shutdown" }]);
+  });
+});

package/src/__tests__/ipc.spec.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import type { IpcMainInvokeEvent } from "electron";
+import { DESKTOP_SCHEME_ARGUMENT, assertDesktopSender, desktopScheme } from "../ipc.ts";
+
+function sender(url: string): IpcMainInvokeEvent {
+  return { senderFrame: { url } } as unknown as IpcMainInvokeEvent;
+}
+
+describe("桌面标识取自 app 名", () => {
+  it("直接用包名（与官方桌面的 dsh-app 错开）", () => {
+    expect(desktopScheme("dsh-custom-next")).toBe("dsh-custom-next");
+  });
+
+  it("去 scope 前缀、转小写、非法字符换成 '-'", () => {
+    expect(desktopScheme("@morlay/dsh_custom")).toBe("dsh-custom");
+    expect(desktopScheme("@morlay/Dsh.Custom+next")).toBe("dsh.custom+next");
+  });
+
+  it("派生不出合法 scheme 时报错", () => {
+    for (const name of ["", "@morlay/", "1app", "_app"]) {
+      expect(() => desktopScheme(name)).toThrow(/does not yield a usable URL scheme/u);
+    }
+  });
+
+  it("发送者校验用传入的 scheme，而不是写死的 dsh-app", () => {
+    const scheme = desktopScheme("dsh-custom-next");
+    expect(() => assertDesktopSender(sender(`${scheme}://app/`), scheme, ["app"])).not.toThrow();
+    expect(() => assertDesktopSender(sender("dsh-app://app/"), scheme, ["app"])).toThrow(
+      /unowned renderer/u,
+    );
+    expect(() => assertDesktopSender(sender(`${scheme}://other/`), scheme, ["app"])).toThrow(
+      /unowned renderer/u,
+    );
+  });
+
+  it("preload 读 scheme 的参数名与主进程注入的一致", () => {
+    expect(DESKTOP_SCHEME_ARGUMENT).toBe("--dsh-desktop-scheme");
+  });
+});

package/src/__tests__/profile-project.spec.ts

@@ -0,0 +1,204 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  PROFILE_RUNTIME_REPORT_NAME,
+  installProfile,
+  runtimeOverrides,
+  workspaceWithOverrides,
+} from "../profile-project.ts";
+
+const roots: string[] = [];
+
+async function workDir(): Promise<string> {
+  const root = await mkdtemp(join(tmpdir(), "dshdev-profile-"));
+  roots.push(root);
+  return root;
+}
+
+async function write(path: string, content: string): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, content);
+}
+
+afterEach(async () => {
+  for (const root of roots.splice(0)) await rm(root, { recursive: true, force: true });
+});
+
+const SETTINGS = `packages:
+  - .
+
+nodeLinker: hoisted
+autoInstallPeers: false
+allowBuilds:
+  node-pty: true
+`;
+
+function report(entries: readonly { name: string; path: string }[]): string {
+  return `${JSON.stringify({ schemaVersion: 1, runtimePackages: entries }, undefined, 2)}\n`;
+}
+
+describe("profile overrides", () => {
+  it("links every reported runtime package to its directory inside the runtime", async () => {
+    const profile = await workDir();
+    const runtime = await workDir();
+    await write(
+      join(profile, PROFILE_RUNTIME_REPORT_NAME),
+      report([
+        { name: "@deepseek-ai/dsh-llm", path: "node_modules/@deepseek-ai/dsh-llm" },
+        {
+          name: "@morlay/ui-conversation-message-actions",
+          path: "node_modules/.pnpm/@morlay+better-session@file+/node_modules/@morlay/ui-conversation-message-actions",
+        },
+      ]),
+    );
+
+    expect(await runtimeOverrides(profile, runtime)).toEqual([
+      { name: "@deepseek-ai/dsh-llm", target: join(runtime, "node_modules/@deepseek-ai/dsh-llm") },
+      {
+        name: "@morlay/ui-conversation-message-actions",
+        target: join(
+          runtime,
+          "node_modules/.pnpm/@morlay+better-session@file+/node_modules/@morlay/ui-conversation-message-actions",
+        ),
+      },
+    ]);
+  });
+
+  it("fails loud when the seed wrote no runtime package report", async () => {
+    const profile = await workDir();
+    await expect(runtimeOverrides(profile, "/runtime")).rejects.toThrow(
+      new RegExp(PROFILE_RUNTIME_REPORT_NAME, "u"),
+    );
+  });
+
+  it("rejects a report whose package list is not an entry array", async () => {
+    const profile = await workDir();
+    await write(
+      join(profile, PROFILE_RUNTIME_REPORT_NAME),
+      `${JSON.stringify({ schemaVersion: 1, runtimePackages: [7] })}\n`,
+    );
+    await expect(runtimeOverrides(profile, "/runtime")).rejects.toThrow(/runtimePackages/u);
+  });
+
+  it("rejects an entry without a runtime path", async () => {
+    const profile = await workDir();
+    await write(
+      join(profile, PROFILE_RUNTIME_REPORT_NAME),
+      report([{ name: "@deepseek-ai/dsh-llm", path: "" }]),
+    );
+    await expect(runtimeOverrides(profile, "/runtime")).rejects.toThrow(/runtimePackages/u);
+  });
+});
+
+describe("profile workspace settings", () => {
+  it("appends the runtime overrides after the profile settings", () => {
+    const text = workspaceWithOverrides(SETTINGS, [
+      { name: "@deepseek-ai/dsh-llm", target: "/app/runtime/node_modules/@deepseek-ai/dsh-llm" },
+    ]);
+
+    expect(text).toContain("nodeLinker: hoisted");
+    expect(text).toContain("allowBuilds:\n  node-pty: true\n");
+    expect(text).toContain(
+      'overrides:\n  "@deepseek-ai/dsh-llm": "link:/app/runtime/node_modules/@deepseek-ai/dsh-llm"\n',
+    );
+  });
+
+  it("replaces the overrides it wrote on an earlier launch", () => {
+    const first = workspaceWithOverrides(SETTINGS, [{ name: "a", target: "/one/a" }]);
+    const second = workspaceWithOverrides(first, [{ name: "b", target: "/two/b" }]);
+
+    expect(second.match(/overrides:/gu)).toHaveLength(1);
+    expect(second).not.toContain("/one/a");
+    expect(second).toContain('"b": "link:/two/b"');
+  });
+
+  it("keeps the settings untouched when no runtime package is overridden", () => {
+    expect(workspaceWithOverrides(SETTINGS, [])).toBe(SETTINGS);
+  });
+
+  it("keeps a hand-edited overrides block when the runtime list is empty", () => {
+    const edited = `${SETTINGS}overrides:\n  "left": "1.0.0"\n`;
+
+    expect(workspaceWithOverrides(edited, [])).toBe(edited);
+  });
+});
+
+describe("profile installation", () => {
+  const spawnStub = (calls: { command: string; args: readonly string[]; cwd: string }[]) =>
+    ((command: string, args: readonly string[], options: { cwd?: string }) => {
+      calls.push({ command, args, cwd: String(options.cwd) });
+      return {
+        on: (event: string, listener: (...rest: unknown[]) => void) => {
+          if (event === "close")
+            setImmediate(() => {
+              listener(0, null);
+            });
+          return undefined;
+        },
+        once: (event: string, listener: (...rest: unknown[]) => void) => {
+          if (event === "close")
+            setImmediate(() => {
+              listener(0, null);
+            });
+          return undefined;
+        },
+      };
+    }) as unknown as typeof import("node:child_process").spawn;
+
+  it("installs the profile offline with the bundled pnpm entry", async () => {
+    const profile = await workDir();
+    const calls: { command: string; args: readonly string[]; cwd: string }[] = [];
+
+    await installProfile({
+      node: "/app/runtime/node/node",
+      pnpmEntry: "/app/runtime/pnpm/bin/pnpm.mjs",
+      profileDir: profile,
+      spawn: spawnStub(calls),
+    });
+
+    expect(calls).toEqual([
+      {
+        command: "/app/runtime/node/node",
+        args: [
+          "/app/runtime/pnpm/bin/pnpm.mjs",
+          "install",
+          "--prod",
+          "--ignore-scripts",
+          "--offline",
+        ],
+        cwd: profile,
+      },
+    ]);
+  });
+
+  it("reports the pnpm exit status when the installation fails", async () => {
+    const profile = await workDir();
+    const failing = ((_command: string, _args: readonly string[], _options: unknown) => ({
+      once: (event: string, listener: (...rest: unknown[]) => void) => {
+        if (event === "close")
+          setImmediate(() => {
+            listener(1, null);
+          });
+        return undefined;
+      },
+      on: (event: string, listener: (...rest: unknown[]) => void) => {
+        if (event === "close")
+          setImmediate(() => {
+            listener(1, null);
+          });
+        return undefined;
+      },
+    })) as unknown as typeof import("node:child_process").spawn;
+
+    await expect(
+      installProfile({
+        node: "/app/runtime/node/node",
+        pnpmEntry: "/app/runtime/pnpm/bin/pnpm.mjs",
+        profileDir: profile,
+        spawn: failing,
+      }),
+    ).rejects.toThrow(/profile install/u);
+  });
+});

package/src/__tests__/seed-profile.spec.ts

@@ -0,0 +1,189 @@
+import { spawn } from "node:child_process";
+import {
+  access,
+  lstat,
+  mkdir,
+  mkdtemp,
+  readFile,
+  readlink,
+  rm,
+  symlink,
+  writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  ensureSeedProfile,
+  PROFILE_MODULES_ARCHIVE_NAME,
+  SEED_DIR_NAME,
+  SEED_HASH_NAME,
+} from "../seed.ts";
+
+const roots: string[] = [];
+
+async function exists(path: string): Promise<boolean> {
+  return await access(path).then(
+    () => true,
+    () => false,
+  );
+}
+
+async function write(path: string, content = ""): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, content);
+}
+
+interface Fixture {
+  readonly seed: string;
+  readonly home: string;
+  readonly seedProfile: string;
+  readonly homeProfile: string;
+}
+
+async function fixture(): Promise<Fixture> {
+  const root = await mkdtemp(resolve(tmpdir(), "dshdev-seed-"));
+  roots.push(root);
+  const seed = join(root, SEED_DIR_NAME);
+  const home = join(root, "home");
+  const seedProfile = join(seed, "profiles", "desktop");
+  await write(join(seedProfile, SEED_HASH_NAME), "abc123");
+  await write(join(seedProfile, "cordis.patch.yml"), "- insert: []\n");
+  return { seed, home, seedProfile, homeProfile: join(home, "profiles", "desktop") };
+}
+
+// 造一份**真的**随包归档（与打包时同名同布局）：`node_modules/<pkg>/…` 打成一个 tar。
+async function makeArchive(seed: string, entries: Readonly<Record<string, string>>): Promise<void> {
+  const stage = join(seed, ".stage");
+  for (const [relative, content] of Object.entries(entries)) {
+    await write(join(stage, ...relative.split("/")), content);
+  }
+  await new Promise<void>((done, fail) => {
+    const child = spawn(
+      "tar",
+      ["czf", join(seed, PROFILE_MODULES_ARCHIVE_NAME), "-C", stage, "node_modules"],
+      { stdio: ["ignore", "ignore", "inherit"] },
+    );
+    child.on("error", fail);
+    child.on("close", (code) =>
+      code === 0 ? done() : fail(new Error(`tar exited with ${String(code)}`)),
+    );
+  });
+}
+
+const ARCHIVE_ONE = { "node_modules/fixture-pkg/index.js": "export default 1;\n" } as const;
+
+afterEach(async () => {
+  for (const root of roots.splice(0)) await rm(root, { recursive: true, force: true });
+});
+
+describe("seed profile planting", () => {
+  it("plants the profile into an empty app home", async () => {
+    const { seed, home, homeProfile } = await fixture();
+
+    expect(await ensureSeedProfile(seed, home)).toBe("seeded");
+    expect(await readFile(join(homeProfile, "cordis.patch.yml"), "utf8")).toBe("- insert: []\n");
+    expect(await readFile(join(homeProfile, SEED_HASH_NAME), "utf8")).toBe("abc123");
+  });
+
+  it("leaves a matching profile alone on the next launch", async () => {
+    const { seed, home, homeProfile } = await fixture();
+    await ensureSeedProfile(seed, home);
+    await write(join(homeProfile, "local-state.json"), "{}\n");
+
+    expect(await ensureSeedProfile(seed, home)).toBe("up-to-date");
+    expect(await readFile(join(homeProfile, "local-state.json"), "utf8")).toBe("{}\n");
+  });
+
+  it("replaces the profile when the seed fingerprint changes", async () => {
+    const { seed, home, homeProfile, seedProfile } = await fixture();
+    await ensureSeedProfile(seed, home);
+    await write(join(homeProfile, "stale.json"), "{}\n");
+
+    await write(join(seedProfile, SEED_HASH_NAME), "def456");
+    await write(join(seedProfile, "extra.json"), "{}\n");
+
+    expect(await ensureSeedProfile(seed, home)).toBe("seeded");
+    expect(await exists(join(homeProfile, "stale.json"))).toBe(false);
+    expect(await exists(join(homeProfile, "extra.json"))).toBe(true);
+    expect(await readFile(join(homeProfile, SEED_HASH_NAME), "utf8")).toBe("def456");
+  });
+
+  it("re-plants everything but the user's own patch document", async () => {
+    const { seed, home, homeProfile, seedProfile } = await fixture();
+    await ensureSeedProfile(seed, home);
+    const settings = "- id: locale\n  config:\n    preference: zh\n";
+    await write(join(homeProfile, "cordis.patch.yml"), settings);
+    await write(join(homeProfile, "stale.json"), "{}\n");
+
+    await write(join(seedProfile, SEED_HASH_NAME), "def456");
+    await write(join(seedProfile, "cordis.patch.yml"), "- id: locale\n");
+
+    expect(await ensureSeedProfile(seed, home)).toBe("seeded");
+
+    // 替换逻辑照旧（种子的文件覆盖、旧文件清掉），只有这一份豁免：settings 写在这里。
+    expect(await readFile(join(homeProfile, "cordis.patch.yml"), "utf8")).toBe(settings);
+    expect(await exists(join(homeProfile, "stale.json"))).toBe(false);
+    expect(await readFile(join(homeProfile, SEED_HASH_NAME), "utf8")).toBe("def456");
+  });
+
+  it("re-plants when the seed carries no fingerprint", async () => {
+    const { seed, home, seedProfile } = await fixture();
+    await rm(join(seedProfile, SEED_HASH_NAME));
+
+    expect(await ensureSeedProfile(seed, home)).toBe("seeded");
+    expect(await ensureSeedProfile(seed, home)).toBe("seeded");
+  });
+
+  it("does nothing when the seed has no desktop profile", async () => {
+    const { seed, home } = await fixture();
+    await rm(join(seed, "profiles"), { recursive: true });
+
+    expect(await ensureSeedProfile(seed, home)).toBe("no-seed");
+    expect(await exists(home)).toBe(false);
+  });
+
+  it("keeps symlinks as links and skips the store directories", async () => {
+    const { seed, home, homeProfile, seedProfile } = await fixture();
+    await write(join(seed, "node_modules", "pkg", "index.js"), "module.exports = {};\n");
+    await symlink(join("..", "..", "node_modules", "pkg"), join(seedProfile, "pkg-link"), "dir");
+    await write(join(seedProfile, ".store", "cached.txt"), "cached\n");
+
+    expect(await ensureSeedProfile(seed, home)).toBe("seeded");
+    expect((await lstat(join(homeProfile, "pkg-link"))).isSymbolicLink()).toBe(true);
+    expect(await readlink(join(homeProfile, "pkg-link"))).toBe(
+      join("..", "..", "node_modules", "pkg"),
+    );
+    expect(await exists(join(homeProfile, ".store"))).toBe(false);
+  });
+
+  it("plants the dependency closure from the shipped archive", async () => {
+    const { seed, home, homeProfile } = await fixture();
+    await makeArchive(seed, ARCHIVE_ONE);
+
+    expect(await ensureSeedProfile(seed, home)).toBe("seeded");
+    expect(await exists(join(homeProfile, "node_modules", "fixture-pkg", "index.js"))).toBe(true);
+    // 依赖面在了，指纹也一致：下一次不该再种。
+    expect(await ensureSeedProfile(seed, home)).toBe("up-to-date");
+  });
+
+  it("re-plants when the fingerprint matches but the closure is gone", async () => {
+    const { seed, home, homeProfile } = await fixture();
+    await makeArchive(seed, ARCHIVE_ONE);
+    await ensureSeedProfile(seed, home);
+
+    // 上一次解压失败、或用户清过：指纹（种子自己的）仍然一致，但依赖面没了——**必须补**，
+    // 否则宿主会带着残缺的 profile 起来（表现是"组件不完整"，而且永远等不到它自愈）。
+    await rm(join(homeProfile, "node_modules"), { recursive: true, force: true });
+
+    expect(await ensureSeedProfile(seed, home)).toBe("seeded");
+    expect(await exists(join(homeProfile, "node_modules", "fixture-pkg", "index.js"))).toBe(true);
+  });
+
+  it("fails loud when the archive does not yield a closure", async () => {
+    const { seed, home } = await fixture();
+    await write(join(seed, PROFILE_MODULES_ARCHIVE_NAME), "not a tar at all\n");
+
+    await expect(ensureSeedProfile(seed, home)).rejects.toThrow(/tar -xzf/u);
+  });
+});