Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

33.9 KB
Raw Blame
import { randomUUID } from "node:crypto";
import { execFile } from "node:child_process";
import { promisify } from "node:util";
import {
  mkdir,
  mkdtemp,
  readFile,
  realpath,
  lstat,
  rm,
  symlink,
  writeFile,
} from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { chdir, cwd } from "node:process";
import { expect, test, vi } from "vitest";
import { createPublishedProjectBundleFixture } from "@webstudio-is/protocol/fixtures";
import {
  ensurePreviewDependencies,
  buildPreparedPreview,
  createPreviewCleanupError,
  getNodeModulesSearchPaths,
  getPreviewBuildCacheKey,
  getPreviewProjectDir,
  preparePreviewProject,
  preview,
  previewDefaultTemplate,
} from "./preview";
import { generatedFilesManifest } from "../prebuild";
import { getPackageManagerInvocation } from "../preview-server/package-manager";
import { resolveConfig } from "vite";
import reactRouterConfig from "../../templates/react-router/vite.config";

test("keeps generated preview caches separate when dependencies are shared", async () => {
  const directory = await mkdtemp(join(tmpdir(), "webstudio-preview-cache-"));
  try {
    const cachePaths: string[] = [];
    for (const name of ["first", "second"]) {
      const projectDir = join(directory, name);
      await mkdir(projectDir);
      await writeFile(
        join(projectDir, "package.json"),
        await readFile(
          new URL("../../templates/react-router/package.json", import.meta.url)
        )
      );
      await ensurePreviewDependencies(projectDir);
      const config = await resolveConfig(
        {
          ...reactRouterConfig,
          root: projectDir,
          configFile: false,
          plugins: [],
        },
        "serve"
      );
      await mkdir(config.cacheDir, { recursive: true });
      cachePaths.push(await realpath(config.cacheDir));
    }
    expect(cachePaths[0]).not.toBe(cachePaths[1]);
  } finally {
    await rm(directory, { recursive: true, force: true });
  }
});

test.each(["build", "dev", "start"])(
  "runs the React Router %s script with linked development dependencies",
  async (script) => {
    const directory = await mkdtemp(join(tmpdir(), "webstudio-preview-bin-"));
    try {
      await writeFile(
        join(directory, "package.json"),
        await readFile(
          new URL("../../templates/react-router/package.json", import.meta.url)
        )
      );
      await ensurePreviewDependencies(directory);
      // The start script must reach the generated server module, not fail in
      // a package-manager launcher before loading it.
      await mkdir(join(directory, "build", "server"), { recursive: true });
      await writeFile(
        join(directory, "build", "server", "index.js"),
        'import { writeFileSync } from "node:fs"; writeFileSync("started", "yes"); process.exit(0);'
      );
      const invocation = getPackageManagerInvocation([
        "run",
        script,
        ...(script === "start" ? [] : ["--", "--help"]),
      ]);
      await promisify(execFile)(invocation.command, invocation.args, {
        cwd: directory,
        env: { ...process.env, PORT: "3000" },
        timeout: 20_000,
      });
      if (script === "start") {
        expect(await readFile(join(directory, "started"), "utf8")).toBe("yes");
      }
    } finally {
      await rm(directory, { recursive: true, force: true });
    }
  }
);

const readWindowsPackageFile = (path: string) => {
  if (path.endsWith("node_modules\\pnpm\\package.json")) {
    return JSON.stringify({
      name: "pnpm",
      bin: { pnpm: "bin/pnpm.cjs" },
    });
  }
  if (path.endsWith("node_modules\\npm\\package.json")) {
    return JSON.stringify({
      name: "npm",
      bin: { npm: "bin/npm-cli.js", npx: "bin/npx-cli.js" },
    });
  }
  throw Object.assign(new Error("missing"), { code: "ENOENT" });
};
const resolveWindowsLauncherPath = (path: string) => path;

test("rejects empty preview host", async () => {
  await expect(
    preview({
      host: "",
      port: 5173,
      generate: false,
      assets: true,
      template: [],
      source: "local",
      imageDomain: undefined,
      "image-domain": undefined,
    })
  ).rejects.toThrow("--host must not be empty.");
});

test("defaults preview generation to one compatible router template", () => {
  expect(previewDefaultTemplate).toEqual(["react-router"]);
});

test("uses Node module search paths to discover installed dependencies", () => {
  expect(
    getNodeModulesSearchPaths(
      "file:///tmp/app/node_modules/webstudio/lib/cli.js"
    )
  ).toContain("/tmp/app/node_modules");
});

test("builds only uncached prepared previews and records the cache key", async () => {
  const runPreviewBuild = vi.fn(async () => undefined);
  const writeFile = vi.fn(async () => undefined);

  await expect(
    buildPreparedPreview(
      {
        cwd: "/tmp/preview",
        buildCacheKey: "cache-key",
        buildRequired: true,
      },
      { runPreviewBuild, writeFile }
    )
  ).resolves.toBe(true);
  expect(runPreviewBuild).toHaveBeenCalledWith(undefined, "/tmp/preview");
  expect(writeFile).toHaveBeenCalledWith(
    "/tmp/preview/.webstudio-preview-build",
    "cache-key"
  );

  runPreviewBuild.mockClear();
  writeFile.mockClear();
  await expect(
    buildPreparedPreview(
      { cwd: "/tmp/preview", buildRequired: false },
      { runPreviewBuild, writeFile }
    )
  ).resolves.toBe(false);
  expect(runPreviewBuild).not.toHaveBeenCalled();
  expect(writeFile).not.toHaveBeenCalled();
});

test("keys packaged preview builds to project inputs and asset metadata", async () => {
  const projectDir = join(tmpdir(), `webstudio-preview-key-${randomUUID()}`);
  await mkdir(join(projectDir, ".webstudio", "assets"), { recursive: true });
  await writeFile(join(projectDir, ".webstudio", "data.json"), "first");
  await writeFile(join(projectDir, ".webstudio", "config.json"), "config");
  await writeFile(join(projectDir, ".webstudio", "assets", "hero.png"), "a");
  try {
    const first = await getPreviewBuildCacheKey({
      projectDir,
      assets: true,
      template: [],
      cliVersion: "1.2.3",
    });
    const same = await getPreviewBuildCacheKey({
      projectDir,
      assets: true,
      template: [],
      cliVersion: "1.2.3",
    });
    const withDraftPages = await getPreviewBuildCacheKey({
      projectDir,
      assets: true,
      template: [],
      includeDraftPages: true,
      cliVersion: "1.2.3",
    });
    await writeFile(join(projectDir, ".webstudio", "data.json"), "second");
    const changed = await getPreviewBuildCacheKey({
      projectDir,
      assets: true,
      template: [],
      cliVersion: "1.2.3",
    });

    expect(first).toBe(same);
    expect(withDraftPages).not.toBe(first);
    expect(changed).not.toBe(first);
    await expect(
      getPreviewBuildCacheKey({
        projectDir,
        assets: true,
        template: [],
        cliVersion: "0.0.0-webstudio-version",
      })
    ).resolves.toBeUndefined();
  } finally {
    await rm(projectDir, { recursive: true, force: true });
  }
});

test("prepares preview by syncing missing data and generating the app template", async () => {
  const syncDependencies = {
    createFileIfNotExists: vi.fn(async () => undefined),
    downloadAssetFiles: vi.fn(async () => undefined),
    isFileExists: vi.fn(async () => true),
    loadProjectBundleByBuildId: vi.fn(),
    loadCurrentProjectBundle: vi.fn(async () =>
      createPublishedProjectBundleFixture()
    ),
    readFile: vi.fn(),
    resolveApiConnection: vi.fn(async () => ({
      origin: "https://example.com",
      authToken: "token",
      projectId: "project",
    })),
    spinner: vi.fn(),
    writeFile: vi.fn(async () => undefined),
    materializeManagedAgents: vi.fn(async () => ({
      path: "/project/AGENTS.md",
      status: "unchanged" as const,
    })),
  };
  const accessLocalDataFile = vi.fn(async () => {
    throw Object.assign(new Error("missing"), { code: "ENOENT" });
  });
  const prebuildProject = vi.fn(async () => undefined);

  const result = await preparePreviewProject({
    assets: true,
    template: [],
    generate: true,
    syncIfMissing: true,
    syncDependencies,
    accessLocalDataFile,
    prebuildProject,
    ensureDependencies: vi.fn(async () => undefined),
  });

  expect(syncDependencies.loadCurrentProjectBundle).toHaveBeenCalled();
  expect(prebuildProject).toHaveBeenCalledWith({
    assets: true,
    template: ["react-router"],
    previewIdentity: true,
    sourceAssetsDirectory: join(cwd(), ".webstudio", "assets"),
  });
  expect(result.cwd).toBe(getPreviewProjectDir());
});

test("prepares local verification previews with draft routes", async () => {
  const prebuildProject = vi.fn(async () => undefined);
  const getBuildCacheKey = vi.fn(async () => "draft-cache-key");

  await preparePreviewProject({
    assets: true,
    template: [],
    generate: true,
    includeDraftPages: true,
    accessLocalDataFile: vi.fn(async () => undefined),
    prebuildProject,
    ensureDependencies: vi.fn(async () => undefined),
    getBuildCacheKey,
  });

  expect(getBuildCacheKey).toHaveBeenCalledWith({
    projectDir: cwd(),
    assets: true,
    template: [],
    includeDraftPages: true,
  });
  expect(prebuildProject).toHaveBeenCalledWith({
    assets: true,
    template: ["react-router"],
    includeDraftPages: true,
    previewIdentity: true,
    sourceAssetsDirectory: join(cwd(), ".webstudio", "assets"),
  });
});

test("generates preview project in isolated directory", async () => {
  const previousDirectory = cwd();
  const projectDir = join(tmpdir(), `webstudio-preview-test-${randomUUID()}`);
  let expectedPreviewProjectDir = "";
  const prebuildProject = vi.fn(async () => {
    expect(cwd()).toBe(expectedPreviewProjectDir);
  });

  await mkdir(join(projectDir, ".webstudio"), { recursive: true });
  await writeFile(join(projectDir, ".webstudio", "data.json"), "{}");
  await writeFile(join(projectDir, ".webstudio", "config.json"), "{}");
  await writeFile(
    join(projectDir, ".webstudio", "project-session.json"),
    "consumer session"
  );
  await mkdir(join(projectDir, ".temp"), { recursive: true });
  await writeFile(join(projectDir, ".temp", "diagnostic.mjs"), "consumer file");
  await mkdir(join(projectDir, ".webstudio", "preview", "node_modules"), {
    recursive: true,
  });
  await writeFile(
    join(projectDir, ".webstudio", "preview", "node_modules", "cached"),
    "preserved"
  );
  const ensureDependencies = vi.fn(async (previewProjectDir: string) => {
    await expect(
      readFile(join(previewProjectDir, "node_modules", "cached"), "utf8")
    ).resolves.toBe("preserved");
  });
  chdir(projectDir);
  expectedPreviewProjectDir = getPreviewProjectDir();
  try {
    await expect(
      preparePreviewProject({
        assets: true,
        template: [],
        generate: true,
        prebuildProject,
        ensureDependencies,
      })
    ).resolves.toEqual({
      cwd: expectedPreviewProjectDir,
      buildRequired: true,
    });
    await expect(
      readFile(join(projectDir, ".webstudio", "project-session.json"), "utf8")
    ).resolves.toBe("consumer session");
    await expect(
      readFile(join(projectDir, ".temp", "diagnostic.mjs"), "utf8")
    ).resolves.toBe("consumer file");
  } finally {
    chdir(previousDirectory);
    await rm(projectDir, { recursive: true, force: true });
  }

  expect(prebuildProject).toHaveBeenCalledWith({
    assets: true,
    template: ["react-router"],
    previewIdentity: true,
    sourceAssetsDirectory: join(expectedPreviewProjectDir, "..", "assets"),
  });
  expect(ensureDependencies).toHaveBeenCalledOnce();
});

test("revalidates dependencies when reusing a cached preview build", async () => {
  const previousDirectory = cwd();
  const projectDir = join(tmpdir(), `webstudio-preview-test-${randomUUID()}`);
  const previewProjectDir = join(projectDir, ".webstudio", "preview");
  const ensureDependencies = vi.fn(async () => undefined);
  const prebuildProject = vi.fn(async () => undefined);

  await mkdir(previewProjectDir, { recursive: true });
  await writeFile(join(projectDir, ".webstudio", "data.json"), "{}");
  await writeFile(
    join(previewProjectDir, ".webstudio-preview-build"),
    "cache-key"
  );
  chdir(projectDir);
  try {
    const result = await preparePreviewProject({
      assets: true,
      template: [],
      generate: true,
      prebuildProject,
      ensureDependencies,
      getBuildCacheKey: vi.fn(async () => "cache-key"),
    });
    expect(result.buildCacheKey).toBe("cache-key");
    expect(result.buildRequired).toBe(false);
    await expect(realpath(result.cwd)).resolves.toBe(
      await realpath(previewProjectDir)
    );
  } finally {
    chdir(previousDirectory);
    await rm(projectDir, { recursive: true, force: true });
  }

  expect(ensureDependencies).toHaveBeenCalledOnce();
  expect(prebuildProject).not.toHaveBeenCalled();
});

test("regenerates a production cache before using it for iterative preview", async () => {
  const previousDirectory = cwd();
  const projectDir = join(tmpdir(), `webstudio-preview-test-${randomUUID()}`);
  const previewProjectDir = join(projectDir, ".webstudio", "preview");
  const prebuildProject = vi.fn(async () => undefined);

  await mkdir(join(projectDir, ".webstudio"), { recursive: true });
  await mkdir(previewProjectDir, { recursive: true });
  await writeFile(join(projectDir, ".webstudio", "data.json"), "{}");
  await writeFile(join(projectDir, ".webstudio", "config.json"), "{}");
  await writeFile(
    join(previewProjectDir, ".webstudio-preview-build"),
    "cache-key"
  );
  chdir(projectDir);
  const sourceAssetsDirectory = join(cwd(), ".webstudio", "assets");
  try {
    const result = await preparePreviewProject({
      assets: true,
      template: [],
      generate: true,
      prepareForIncrementalGeneration: true,
      prebuildProject,
      ensureDependencies: vi.fn(async () => undefined),
      getBuildCacheKey: vi.fn(async () => "cache-key"),
    });

    expect(result.buildRequired).toBe(true);
  } finally {
    chdir(previousDirectory);
    await rm(projectDir, { recursive: true, force: true });
  }

  expect(prebuildProject).toHaveBeenCalledWith({
    assets: true,
    template: ["react-router"],
    preserveRouteTemplates: true,
    previewIdentity: true,
    sourceAssetsDirectory,
  });
});

test("links local workspace preview dependencies without asking npm for placeholder versions", async () => {
  const symlink = vi.fn(async () => undefined);
  const cliNodeModules = getNodeModulesSearchPaths(import.meta.url).find(
    (path) => path.endsWith("/packages/cli/node_modules")
  );
  expect(cliNodeModules).toBeDefined();
  const access = vi.fn(async (path: string) => {
    if (path.startsWith(cliNodeModules!) === false) {
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }
  });
  const execFile = vi.fn(async () => ({ stdout: "", stderr: "" }));

  await ensurePreviewDependencies("/tmp/project/.webstudio/preview", {
    access,
    execFile,
    lstat: vi.fn(async () => {
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }),
    readFile: vi.fn(
      async () =>
        '{"dependencies":{"@webstudio-is/image":"0.0.0-webstudio-version","vite":"1.0.0"}}'
    ),
    symlink,
    platform: "linux",
  });

  expect(symlink).toHaveBeenCalledWith(
    cliNodeModules,
    "/tmp/project/.webstudio/preview/node_modules",
    "dir"
  );
  expect(execFile).not.toHaveBeenCalled();
});

test("does not relink generated preview dependencies when already present", async () => {
  const symlink = vi.fn(async () => undefined);
  const access = vi.fn(async () => undefined);

  await ensurePreviewDependencies("/tmp/project/.webstudio/preview", {
    access,
    lstat: vi.fn(async () => ({ isSymbolicLink: () => true })) as never,
    readFile: vi.fn(
      async () =>
        '{"dependencies":{"@webstudio-is/sdk":"0.0.0-webstudio-version"}}'
    ),
    symlink,
    platform: "linux",
  });

  expect(symlink).not.toHaveBeenCalled();
});

test("uses junctions for generated preview dependencies on windows", async () => {
  const symlink = vi.fn(async () => undefined);
  const cliNodeModules = getNodeModulesSearchPaths(import.meta.url).find(
    (path) => path.endsWith("/packages/cli/node_modules")
  );
  expect(cliNodeModules).toBeDefined();
  const access = vi.fn(async (path: string) => {
    if (path.startsWith(cliNodeModules!) === false) {
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }
  });

  await ensurePreviewDependencies("C:/project/.webstudio/preview", {
    access,
    lstat: vi.fn(async () => {
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }),
    readFile: vi.fn(
      async () =>
        '{"dependencies":{"@webstudio-is/sdk":"0.0.0-webstudio-version"}}'
    ),
    symlink,
    platform: "win32",
  });

  expect(symlink).toHaveBeenCalledWith(
    cliNodeModules,
    "C:/project/.webstudio/preview/node_modules",
    "junction"
  );
});

test.each([
  {
    name: "npm" as const,
    command: "npm",
    path: "/usr/bin",
    args: expect.arrayContaining(["install", "--legacy-peer-deps"]),
  },
  {
    name: "pnpm" as const,
    command: "/usr/local/bin/pnpm",
    path: "/usr/local/bin:/usr/bin",
    args: [
      "install",
      "--no-lockfile",
      "--loglevel=error",
      "--ignore-workspace",
    ],
  },
])(
  "installs isolated generated dependencies with $name",
  async ({ name, command, path, args }) => {
    let installed = false;
    const execFile = vi.fn(async () => {
      installed = true;
      return { stdout: "", stderr: "" };
    });
    const writeFile = vi.fn(async () => undefined);

    await ensurePreviewDependencies("/tmp/project/.webstudio/preview", {
      access: vi.fn(async (path) => {
        if (installed && path.startsWith("/tmp/project/.webstudio/preview")) {
          return;
        }
        throw Object.assign(new Error("missing"), { code: "ENOENT" });
      }),
      execFile,
      lstat: vi.fn(async () => {
        throw Object.assign(new Error("missing"), { code: "ENOENT" });
      }),
      readFile: vi.fn(async () => '{"dependencies":{"vite":"1.0.0"}}'),
      writeFile,
      nodeExecPath: "/opt/webstudio-node/bin/node",
      npmExecPath: undefined,
      platform: "linux",
      env: { PATH: path },
      which: (candidate) => (candidate === name ? command : undefined),
    });

    expect(execFile).toHaveBeenCalledWith(
      command,
      args,
      expect.objectContaining({
        cwd: "/tmp/project/.webstudio/preview",
        timeout: 120_000,
        ...(name === "npm"
          ? {
              env: expect.objectContaining({
                PATH: "/opt/webstudio-node/bin:/usr/bin",
                npm_config_cache: "/tmp/project/.webstudio/preview/.npm-cache",
              }),
            }
          : {}),
      })
    );
    expect(writeFile).toHaveBeenCalledWith(
      "/tmp/project/.webstudio/preview/node_modules/.webstudio-preview-dependencies",
      expect.stringMatching(/^[a-f0-9]{64}$/)
    );
  }
);

test("replaces a parent workspace dependency link for published previews", async () => {
  const parentDir = await mkdtemp(
    join(tmpdir(), "webstudio-parent-workspace-")
  );
  const previewProjectDir = join(parentDir, "task", ".webstudio", "preview");
  const parentNodeModules = join(parentDir, "node_modules");
  const packagePath = join(
    "@webstudio-is",
    "sdk-components-react-router",
    "package.json"
  );
  const execFile = vi.fn(async (_command, args: string[]) => {
    expect(args).toContain("--workspaces=false");
    await mkdir(join(previewProjectDir, "node_modules", packagePath, ".."), {
      recursive: true,
    });
    await writeFile(
      join(previewProjectDir, "node_modules", packagePath),
      '{"version":"0.289.0"}'
    );
    return { stdout: "", stderr: "" };
  });

  try {
    await mkdir(join(parentNodeModules, packagePath, ".."), {
      recursive: true,
    });
    await writeFile(
      join(parentNodeModules, packagePath),
      '{"version":"0.0.0-webstudio-version"}'
    );
    await mkdir(previewProjectDir, { recursive: true });
    await writeFile(
      join(previewProjectDir, "package.json"),
      '{"dependencies":{"@webstudio-is/sdk-components-react-router":"0.289.0"}}'
    );
    await symlink(
      parentNodeModules,
      join(previewProjectDir, "node_modules"),
      "dir"
    );

    await ensurePreviewDependencies(previewProjectDir, {
      execFile,
      npmExecPath: undefined,
    });

    expect(await realpath(join(previewProjectDir, "node_modules"))).not.toBe(
      await realpath(parentNodeModules)
    );
    expect(
      (await lstat(join(previewProjectDir, "node_modules"))).isSymbolicLink()
    ).toBe(false);
    expect(execFile).toHaveBeenCalledOnce();
  } finally {
    await rm(parentDir, { recursive: true, force: true });
  }
});

test("reuses the npm cli that launched webstudio on windows", async () => {
  let installed = false;
  const execFile = vi.fn(async () => {
    installed = true;
    return { stdout: "", stderr: "" };
  });

  await ensurePreviewDependencies("/tmp/project/.webstudio/preview", {
    access: vi.fn(async (path) => {
      if (installed && path.startsWith("/tmp/project/.webstudio/preview")) {
        return;
      }
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }),
    execFile,
    lstat: vi.fn(async () => {
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }),
    readFile: vi.fn(async () => '{"dependencies":{"vite":"1.0.0"}}'),
    nodeExecPath: "C:\\Program Files\\nodejs\\node.exe",
    npmExecPath:
      "C:\\Program Files\\nodejs\\node_modules\\npm\\bin\\npm-cli.js",
    readPackageFile: readWindowsPackageFile,
    resolveLauncherPath: resolveWindowsLauncherPath,
    platform: "win32",
    writeFile: vi.fn(async () => undefined),
  });

  expect(execFile).toHaveBeenCalledWith(
    "C:\\Program Files\\nodejs\\node.exe",
    expect.arrayContaining([
      "C:\\Program Files\\nodejs\\node_modules\\npm\\bin\\npm-cli.js",
      "install",
    ]),
    expect.objectContaining({ cwd: "/tmp/project/.webstudio/preview" })
  );
});

test("uses npm-cli from an npx launcher and forwards a writable npm cache", async () => {
  let installed = false;
  const execFile = vi.fn(async () => {
    installed = true;
    return { stdout: "", stderr: "" };
  });
  const env = { npm_config_cache: "C:\\workspace\\.npm-cache" };

  await ensurePreviewDependencies("C:/project/.webstudio/preview", {
    access: vi.fn(async (path) => {
      if (installed && path.startsWith("C:/project/.webstudio/preview")) {
        return;
      }
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }),
    execFile,
    lstat: vi.fn(async () => {
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }),
    readFile: vi.fn(async () => '{"dependencies":{"vite":"1.0.0"}}'),
    nodeExecPath: "C:\\Program Files\\nodejs\\node.exe",
    npmExecPath:
      "C:\\Program Files\\nodejs\\node_modules\\npm\\bin\\npx-cli.js",
    readPackageFile: readWindowsPackageFile,
    resolveLauncherPath: resolveWindowsLauncherPath,
    platform: "win32",
    env,
    writeFile: vi.fn(async () => undefined),
  });

  expect(execFile).toHaveBeenCalledWith(
    "C:\\Program Files\\nodejs\\node.exe",
    expect.arrayContaining([
      "C:\\Program Files\\nodejs\\node_modules\\npm\\bin\\npm-cli.js",
      "install",
    ]),
    {
      cwd: "C:/project/.webstudio/preview",
      env: {
        ...env,
        Path: "C:\\Program Files\\nodejs",
      },
      timeout: 120_000,
    }
  );
});

test("installs generated dependencies through the available windows pnpm launcher", async () => {
  let installed = false;
  const execFile = vi.fn(async () => {
    installed = true;
    return { stdout: "", stderr: "" };
  });

  await ensurePreviewDependencies("C:/project/.webstudio/preview", {
    access: vi.fn(async (path) => {
      if (installed && path.startsWith("C:/project/.webstudio/preview")) {
        return;
      }
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }),
    execFile,
    lstat: vi.fn(async () => {
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }),
    readFile: vi.fn(async () => '{"dependencies":{"vite":"1.0.0"}}'),
    nodeExecPath: "C:\\Program Files\\Codex\\node.exe",
    npmExecPath: "C:\\Program Files\\Codex\\node_modules\\pnpm\\bin\\pnpm.cjs",
    readPackageFile: readWindowsPackageFile,
    resolveLauncherPath: resolveWindowsLauncherPath,
    platform: "win32",
    writeFile: vi.fn(async () => undefined),
  });

  expect(execFile).toHaveBeenCalledWith(
    "C:\\Program Files\\Codex\\node.exe",
    [
      "C:\\Program Files\\Codex\\node_modules\\pnpm\\bin\\pnpm.cjs",
      "install",
      "--no-lockfile",
      "--loglevel=error",
      "--ignore-workspace",
    ],
    expect.objectContaining({ cwd: "C:/project/.webstudio/preview" })
  );
});

test("reports an actionable, stable error when generated dependencies cannot install", async () => {
  const access = vi.fn(async () => {
    throw Object.assign(new Error("missing"), { code: "ENOENT" });
  });

  const failedInstall = ensurePreviewDependencies(
    "/tmp/project/.webstudio/preview",
    {
      access,
      execFile: vi.fn(async () => {
        throw new Error("npm failed");
      }),
      lstat: vi.fn(async () => {
        throw Object.assign(new Error("missing"), { code: "ENOENT" });
      }),
      readFile: vi.fn(async () => '{"dependencies":{"vite":"1.0.0"}}'),
      symlink: vi.fn(async () => undefined),
      platform: "linux",
    }
  );
  await expect(failedInstall).rejects.toThrow(
    "PREVIEW_DEPENDENCY_INSTALL_FAILED: Could not install the generated preview dependencies"
  );
  await expect(failedInstall).rejects.toMatchObject({
    code: "PREVIEW_DEPENDENCY_INSTALL_FAILED",
  });
});

test("reports sanitized package-manager diagnostics for preview install failures", async () => {
  const installError = Object.assign(new Error("npm install failed"), {
    code: 1,
    stderr:
      "npm error code EACCES\nnpm error cache C:\\Users\\agent\\.npm authToken=private-token",
  });

  const promise = ensurePreviewDependencies("C:/project/.webstudio/preview", {
    access: vi.fn(async () => {
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }),
    execFile: vi.fn(async () => {
      throw installError;
    }),
    lstat: vi.fn(async () => {
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }),
    readFile: vi.fn(async () => '{"dependencies":{"vite":"1.0.0"}}'),
    nodeExecPath: "C:\\Program Files\\nodejs\\node.exe",
    npmExecPath:
      "C:\\Program Files\\nodejs\\node_modules\\npm\\bin\\npm-cli.js",
    readPackageFile: readWindowsPackageFile,
    resolveLauncherPath: resolveWindowsLauncherPath,
    platform: "win32",
  });

  await expect(promise).rejects.toThrow(
    "with npm at C:\\Program Files\\nodejs\\node_modules\\npm\\bin\\npm-cli.js"
  );
  await expect(promise).rejects.toThrow("npm error code EACCES");
  await expect(promise).rejects.toThrow("package-manager exit code 1");
  await expect(promise).rejects.toThrow("authToken=[redacted]");
  await expect(promise).rejects.not.toThrow("private-token");
});

test("distinguishes package-manager process errors from exit codes", async () => {
  const promise = ensurePreviewDependencies("/tmp/project/.webstudio/preview", {
    access: vi.fn(async () => {
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }),
    execFile: vi.fn(async () => {
      throw Object.assign(new Error("spawn npm ENOENT"), { code: "ENOENT" });
    }),
    lstat: vi.fn(async () => {
      throw Object.assign(new Error("missing"), { code: "ENOENT" });
    }),
    readFile: vi.fn(async () => '{"dependencies":{"vite":"1.0.0"}}'),
    npmExecPath: undefined,
    platform: "linux",
  });

  await expect(promise).rejects.toThrow("package-manager process error ENOENT");
  await expect(promise).rejects.not.toThrow("exit code ENOENT");
});

test("rejects an incomplete generated dependency tree", async () => {
  await expect(
    ensurePreviewDependencies("/tmp/project/.webstudio/preview", {
      access: vi.fn(async () => {
        throw Object.assign(new Error("missing"), { code: "ENOENT" });
      }),
      execFile: vi.fn(async () => ({ stdout: "", stderr: "" })),
      lstat: vi.fn(async () => {
        throw Object.assign(new Error("missing"), { code: "ENOENT" });
      }),
      readFile: vi.fn(async () => '{"dependencies":{"vite":"1.0.0"}}'),
      npmExecPath: undefined,
      platform: "linux",
    })
  ).rejects.toThrow(
    "PREVIEW_DEPENDENCIES_MISSING: npm completed without installing every dependency"
  );
});

test("materializes session data before previewing from session source", async () => {
  const previousDirectory = cwd();
  const projectDir = join(tmpdir(), `webstudio-preview-test-${randomUUID()}`);
  let expectedPreviewProjectDir = "";
  const progress: string[] = [];
  const prepareSessionDataFile = vi.fn(async () => {
    await mkdir(join(projectDir, ".webstudio"), { recursive: true });
    await writeFile(join(projectDir, ".webstudio", "data.json"), "{}");
    await writeFile(join(projectDir, ".webstudio", "config.json"), "{}");
  });
  const prebuildProject = vi.fn(async () => {
    expect(cwd()).toBe(expectedPreviewProjectDir);
  });

  await mkdir(projectDir, { recursive: true });
  chdir(projectDir);
  expectedPreviewProjectDir = getPreviewProjectDir();
  try {
    await expect(
      preparePreviewProject({
        assets: true,
        template: [],
        generate: true,
        source: "session",
        prepareSessionDataFile,
        prebuildProject,
        ensureDependencies: vi.fn(async () => undefined),
        reportProgress: (message) => progress.push(message),
      })
    ).resolves.toEqual({
      cwd: expectedPreviewProjectDir,
      buildRequired: true,
    });
  } finally {
    chdir(previousDirectory);
    await rm(projectDir, { recursive: true, force: true });
  }

  expect(prepareSessionDataFile).toHaveBeenCalledOnce();
  expect(prebuildProject).toHaveBeenCalledWith({
    assets: true,
    template: ["react-router"],
    previewIdentity: true,
    sourceAssetsDirectory: join(expectedPreviewProjectDir, "..", "assets"),
  });
  expect(progress).toEqual([
    "materializing session project data",
    "generating preview files",
    "checking or installing generated preview dependencies (2 minute timeout)",
    "generated preview project is ready",
  ]);
});

test("refreshes an iterative generated project without replacing its directory", async () => {
  const previousDirectory = cwd();
  const projectDir = join(tmpdir(), `webstudio-preview-test-${randomUUID()}`);
  const previewProjectDir = join(projectDir, ".webstudio", "preview");
  const prebuildProject = vi.fn(async () => {
    await expect(
      readFile(join(previewProjectDir, "server-marker"), "utf8")
    ).resolves.toBe("running");
  });

  await mkdir(join(projectDir, ".webstudio"), { recursive: true });
  await mkdir(join(previewProjectDir, "app", "route-templates"), {
    recursive: true,
  });
  await mkdir(join(previewProjectDir, ".webstudio"), { recursive: true });
  await writeFile(join(projectDir, ".webstudio", "data.json"), "{}");
  await writeFile(join(previewProjectDir, "server-marker"), "running");
  await writeFile(join(previewProjectDir, generatedFilesManifest), "[]");
  chdir(projectDir);
  try {
    await preparePreviewProject({
      assets: true,
      template: [],
      generate: true,
      preserveGeneratedProject: true,
      prebuildProject,
      ensureDependencies: vi.fn(async () => undefined),
    });
  } finally {
    chdir(previousDirectory);
    await rm(projectDir, { recursive: true, force: true });
  }

  expect(prebuildProject).toHaveBeenCalledOnce();
});

test("builds the isolated generated project when generation is disabled", async () => {
  const previousDirectory = cwd();
  const projectDir = join(tmpdir(), `webstudio-preview-test-${randomUUID()}`);
  const previewProjectDir = getPreviewProjectDir(projectDir);
  const prebuildProject = vi.fn(async () => undefined);

  await mkdir(previewProjectDir, { recursive: true });
  await writeFile(join(projectDir, ".webstudio", "data.json"), "{}");
  await writeFile(
    join(previewProjectDir, "package.json"),
    JSON.stringify({
      scripts: {
        build: `node -e "require('node:fs').writeFileSync('built.txt', 'yes')"`,
      },
    })
  );
  chdir(projectDir);
  try {
    await expect(
      readFile(join(projectDir, "package.json"))
    ).rejects.toMatchObject({
      code: "ENOENT",
    });
    const prepared = await preparePreviewProject({
      assets: true,
      template: [],
      generate: false,
      prebuildProject,
    });
    expect(prepared).toEqual({ cwd: getPreviewProjectDir() });
    await buildPreparedPreview(prepared);
    await expect(
      readFile(join(previewProjectDir, "built.txt"), "utf8")
    ).resolves.toBe("yes");
  } finally {
    chdir(previousDirectory);
    await rm(projectDir, { recursive: true, force: true });
  }

  expect(prebuildProject).not.toHaveBeenCalled();
});

test("keeps the standalone React Router preview template", async () => {
  const prebuildProject = vi.fn(async () => undefined);

  await preparePreviewProject({
    assets: true,
    template: ["react-router"],
    generate: true,
    prebuildProject,
    ensureDependencies: vi.fn(async () => undefined),
    accessLocalDataFile: vi.fn(async () => undefined),
  });

  expect(prebuildProject).toHaveBeenCalledWith({
    assets: true,
    template: ["react-router"],
    previewIdentity: true,
    sourceAssetsDirectory: join(cwd(), ".webstudio", "assets"),
  });
});

test("reports the locked preview path, owned PID, and scoped recovery", async () => {
  const error = await createPreviewCleanupError({
    previewProjectDir: "/project/.webstudio/preview",
    lockedPath: "/project/.webstudio/preview/app/routes.tsx",
    cause: Object.assign(new Error("operation not permitted"), {
      code: "EPERM",
    }),
    readOwnerFile: vi.fn(async () =>
      JSON.stringify({ supervisorPid: 120, previewPid: 121 })
    ) as never,
  });

  expect(error.message).toContain("/project/.webstudio/preview/app/routes.tsx");
  expect(error.message).toContain("Recorded owned preview PIDs: 120, 121");
  expect(error.message).toContain("taskkill.exe /pid 121 /t /f");
  expect(error.message).toContain("kill -- -121");
});