Skip to content

Write HTML. Render video. Built for agents.

5.0 KB
Raw Blame
import {
  existsSync,
  mkdtempSync,
  mkdirSync,
  readFileSync,
  writeFileSync,
  symlinkSync,
  lstatSync,
  chmodSync,
  linkSync,
  rmSync,
  readdirSync,
} from "node:fs";
import { join } from "node:path";
import { tmpdir } from "node:os";
import { expect, it } from "vitest";
import { publishRegistryFile, registryRoot, registryTargetPath } from "./publication.js";

it("rejects traversal, Windows aliases and streams before publication", () => {
  const root = registryRoot(mkdtempSync(join(tmpdir(), "hf-publish-")));
  try {
    for (const target of [
      "../outside",
      "/absolute",
      "C:alias",
      "file:stream",
      "CON.txt",
      "nul",
      "folder/LPT1.txt",
      "trailing.",
      "trailing ",
      "a//b",
      "a/./b",
    ]) {
      expect(() => registryTargetPath(root, target), target).toThrow(/Unsafe target/);
    }
    expect(readdirSync(root)).toEqual([]);
  } finally {
    rmSync(root, { recursive: true, force: true });
  }
});
it("protects external leaf symlinks including the install record", () => {
  const root = registryRoot(mkdtempSync(join(tmpdir(), "hf-publish-")));
  const outside = mkdtempSync(join(tmpdir(), "hf-outside-"));
  try {
    const victim = join(outside, "victim.json");
    writeFileSync(victim, "original");
    for (const target of ["file.html", "hyperframes.lock.json"]) {
      symlinkSync(victim, join(root, target), "file");
      expect(() => publishRegistryFile(root, target, "attack")).toThrow(/Unsafe target/);
      expect(readFileSync(victim, "utf8")).toBe("original");
    }
  } finally {
    rmSync(root, { recursive: true, force: true });
    rmSync(outside, { recursive: true, force: true });
  }
});
it("atomically replaces a hard-linked leaf without altering its other name", () => {
  const root = registryRoot(mkdtempSync(join(tmpdir(), "hf-publish-")));
  try {
    writeFileSync(join(root, "original"), "old");
    linkSync(join(root, "original"), join(root, "target"));
    publishRegistryFile(root, "target", "new");
    expect(readFileSync(join(root, "original"), "utf8")).toBe("old");
    expect(readFileSync(join(root, "target"), "utf8")).toBe("new");
    mkdirSync(join(root, "directory"));
    expect(() => publishRegistryFile(root, "directory", "cannot replace directory")).toThrow();
    expect(readdirSync(root).some((name) => name.startsWith(".hf-install-"))).toBe(false);
  } finally {
    rmSync(root, { recursive: true, force: true });
  }
});

it("does not recreate a project folder renamed away before an install", () => {
  const parent = mkdtempSync(join(tmpdir(), "hf-publish-gone-"));
  try {
    const project = join(parent, "film");
    expect(() => registryRoot(project)).toThrow(/Project folder not found/);
    expect(existsSync(project)).toBe(false);
  } finally {
    rmSync(parent, { recursive: true, force: true });
  }
});

it("publishes through an internal leaf alias to its physical target", () => {
  const root = registryRoot(mkdtempSync(join(tmpdir(), "hf-publish-")));
  try {
    mkdirSync(join(root, "nested"));
    writeFileSync(join(root, "nested/physical"), "old");
    symlinkSync(join(root, "nested/physical"), join(root, "alias"), "file");
    publishRegistryFile(root, "alias", "new");
    expect(lstatSync(join(root, "alias")).isSymbolicLink()).toBe(true);
    expect(readFileSync(join(root, "nested/physical"), "utf8")).toBe("new");
  } finally {
    rmSync(root, { recursive: true, force: true });
  }
});

it.skipIf(process.platform === "win32")(
  "publishes through a leaf alias whose target climbs out of a linked folder to the file it resolves",
  () => {
    const root = registryRoot(mkdtempSync(join(tmpdir(), "hf-publish-")));
    try {
      mkdirSync(join(root, "deep", "nested"), { recursive: true });
      mkdirSync(join(root, "m"));
      writeFileSync(join(root, "deep", "y.html"), "old");
      writeFileSync(join(root, "y.html"), "decoy");
      symlinkSync(join(root, "deep", "nested"), join(root, "sub"), "dir");
      symlinkSync("../sub/../y.html", join(root, "m", "x.html"), "file");
      publishRegistryFile(root, "m/x.html", "new");
      expect(readFileSync(join(root, "deep", "y.html"), "utf8")).toBe("new");
      expect(readFileSync(join(root, "y.html"), "utf8")).toBe("decoy");
    } finally {
      rmSync(root, { recursive: true, force: true });
    }
  },
);

it.skipIf(process.platform === "win32")(
  "preserves executable mode when replacing an installed file",
  () => {
    const root = registryRoot(mkdtempSync(join(tmpdir(), "hf-mode-")));
    try {
      const path = join(root, "script.sh");
      writeFileSync(path, "old");
      chmodSync(path, 0o755);
      publishRegistryFile(root, "script.sh", "new");
      expect(lstatSync(path).mode & 0o777).toBe(0o755);
      symlinkSync(path, join(root, "alias"), "file");
      publishRegistryFile(root, "alias", "via alias");
      expect(lstatSync(path).mode & 0o777).toBe(0o755);
      expect(lstatSync(join(root, "alias")).isSymbolicLink()).toBe(true);
    } finally {
      rmSync(root, { recursive: true, force: true });
    }
  },
);