feat: enforce ascii slugs

Author: bhdicaire

scripts/build-redirect-targets.mjs

@@ -56,6 +56,10 @@ function parseTags(value) {
     .filter(Boolean);
 }
 
+function isValidSlugSegment(segment) {
+  return /^[A-Za-z0-9][A-Za-z0-9._~-]*$/.test(segment);
+}
+
 function normalizeTarget(value) {
   const target = String(value || "").trim();
   if (target.startsWith("//")) return target;
@@ -355,6 +359,14 @@ function parseLine(line, lineNumber, blocklistPolicy, errors) {
     errors.push(`Line ${lineNumber}: invalid slug "${displaySlug}"`);
   }
 
+  for (const segment of slug.split("/")) {
+    if (!isValidSlugSegment(segment)) {
+      errors.push(
+        `Line ${lineNumber}: invalid slug segment "${segment}" for "${displaySlug}"; use ASCII letters, digits, dot, underscore, tilde, or hyphen`
+      );
+    }
+  }
+
   if (match === "splat" && !target.includes(":splat")) {
     errors.push(`Line ${lineNumber}: splat target for "${displaySlug}" must include :splat`);
   }

scripts/build.mjs

@@ -473,23 +473,47 @@ function applyLegalBranding(html, siteConfig, language = "en") {
 
 function applyPublicBranding(siteConfig) {
   const slogans = siteConfig?.branding?.slogan;
-  if (!hasConfiguredSlogan(slogans)) return;
+  const wordmark = siteConfig?.branding?.wordmark;
+  const hasWordmark = Boolean(wordmark?.black || wordmark?.green);
+  const hasSlogan = hasConfiguredSlogan(slogans);
+  if (!hasWordmark && !hasSlogan) return;
 
   rewriteHtmlFiles(BUILD_DIR, (html, filePath) => {
-    if (!html.includes('class="instance-brand-subtitle"')) return html;
+    let brandedHtml = html;
+    const brandLabel = hasWordmark ? `${wordmark.black || ""}${wordmark.green || ""}` : "";
+
+    if (hasWordmark) {
+      const renderedWordmark = renderConfiguredWordmark(siteConfig);
+      brandedHtml = brandedHtml
+        .replace(/<h1([^>]*)><span>Vanity<\/span><span>URLs<\/span><\/h1>/g, `<h1$1>${renderedWordmark}</h1>`)
+        .replace(
+          /(<h1 class="instance-brand-title">\s*<a href="[^"]+" aria-label=")[^"]*("[^>]*>)[\s\S]*?(<\/a>\s*<\/h1>)/g,
+          `$1${escapeHtmlAttribute(brandLabel)}$2${renderedWordmark}$3`
+        )
+        .replace(/<title>([^<]*?)VanityURLs([^<]*?)<\/title>/gi, `<title>$1${escapeHtml(brandLabel)}$2</title>`)
+        .replace(/aria-label="VanityURLs"/g, `aria-label="${escapeHtmlAttribute(brandLabel)}"`)
+        .replace(
+          /(<a class="wordmark" href=)"https:\/\/vanityurls\.link\/"/gi,
+          `$1"https://${escapeHtmlAttribute(siteConfig?.operator?.short_domain || brandLabel)}/"`
+        );
+    }
+
+    if (!hasSlogan) return brandedHtml;
 
     const language = languageForBuildHtmlFile(filePath);
     const slogan = renderBrandingSlogan(
       localizedSlogan(slogans, language),
       siteConfig?.operator,
       localizedSloganLinkText(siteConfig?.branding?.slogan_link_text, language)
     );
-    if (!slogan) return html;
+    if (!slogan) return brandedHtml;
+    const subtitle = `<p class="instance-brand-subtitle">${slogan}</p>`;
 
-    return html.replace(
-      /<p class="instance-brand-subtitle">[\s\S]*?<\/p>/,
-      `<p class="instance-brand-subtitle">${slogan}</p>`
-    );
+    if (!brandedHtml.includes('class="instance-brand-subtitle"')) {
+      return brandedHtml.replace(/(<a class="wordmark"[\s\S]*?<\/a>)/, `$1\n\n        ${subtitle}`);
+    }
+
+    return brandedHtml.replace(/<p class="instance-brand-subtitle">[\s\S]*?<\/p>/, subtitle);
   });
 }
 

scripts/install.mjs

@@ -254,8 +254,8 @@ async function promptForMissing(args) {
         : {};
       args.customizePublic = await confirm(
         rl,
-        "Copy default web pages to custom/public with a split-color domain wordmark?",
-        siteConfig.branding?.custom_public !== false
+        "Copy full default web pages to custom/public for manual template editing?",
+        siteConfig.branding?.custom_public === true
       );
       args.wordmarkBlack = await question(
         rl,
@@ -302,7 +302,7 @@ function normalizeArgs(args) {
   if (!args.workerName) throw new Error("Worker name cannot be empty.");
   validateWorkerName(args.workerName);
   validateOperator(args.operator);
-  if (args.customizePublic) {
+  if (args.configureBranding) {
     const split = normalizeWordmarkSplit(args);
     args.wordmarkBlack = split.black;
     args.wordmarkGreen = split.green;
@@ -741,12 +741,10 @@ function updateSiteConfig(args) {
           slogan: args.brandingSlogans,
           slogan_link_text: existingSiteConfig.branding?.slogan_link_text || {},
           custom_public: args.customizePublic === true,
-          wordmark: args.customizePublic
-            ? {
-                black: args.wordmarkBlack,
-                green: args.wordmarkGreen
-              }
-            : undefined
+          wordmark: {
+            black: args.wordmarkBlack,
+            green: args.wordmarkGreen
+          }
         }
       : {
           ...(existingSiteConfig.branding || {}),

scripts/install.test.mjs

@@ -112,4 +112,51 @@ function runSetup(cwd, extraArgs) {
   );
 }
 
+{
+  const fixture = makeFixture();
+
+  runSetup(fixture, [
+    "--domain",
+    "v8s.link",
+    "--worker-name",
+    "v8s-link",
+    "--owner",
+    "team",
+    "--languages",
+    "en,fr",
+    "--operator-timezone",
+    "America/Toronto",
+    "--operator-legal-name",
+    "Example Inc.",
+    "--operator-domain",
+    "example.com",
+    "--operator-abuse-contact",
+    "abuse@example.com",
+    "--operator-security-contact",
+    "security@example.com",
+    "--branding-slogan",
+    "The official demo for Example Inc. projects",
+    "--wordmark-black",
+    "v8s.",
+    "--wordmark-green",
+    "link",
+    "--no-customize-public"
+  ]);
+
+  const siteConfig = JSON.parse(fs.readFileSync(path.join(fixture, "custom", "v8s-site-config.json"), "utf8"));
+  assert.equal(siteConfig.branding.custom_public, false);
+  assert.equal(siteConfig.branding.wordmark.black, "v8s.");
+  assert.equal(siteConfig.branding.wordmark.green, "link");
+  assert.equal(fs.existsSync(path.join(fixture, "custom", "public", "en", "index.html")), false);
+
+  execFileSync(process.execPath, ["scripts/build.mjs"], {
+    cwd: fixture,
+    stdio: "pipe"
+  });
+
+  const builtIndex = fs.readFileSync(path.join(fixture, "build", "index.html"), "utf8");
+  assert.match(builtIndex, /<span>v8s\.<\/span><span>link<\/span>/);
+  assert.match(builtIndex, /The official demo for <a href="https:\/\/example\.com">Example Inc\.<\/a> projects/);
+}
+
 console.log("install tests ok");

scripts/registry.test.mjs

@@ -36,6 +36,24 @@ execFileSync(process.execPath, ["scripts/validate-runtime-registry.mjs", registr
   stdio: "pipe"
 });
 
+fs.writeFileSync(
+  linksPath,
+  [
+    "# slug|target|state|title|description|tags|owner|expires_at|notes",
+    "déplier|https://example.com/docs|permanent|Docs|Docs home|docs|team||",
+    ""
+  ].join("\n")
+);
+
+assert.throws(
+  () =>
+    execFileSync(process.execPath, ["scripts/build-redirect-targets.mjs", linksPath, registryPath], {
+      encoding: "utf8",
+      stdio: "pipe"
+    }),
+  (error) => String(error.stderr || "").includes("invalid slug segment")
+);
+
 const registry = JSON.parse(fs.readFileSync(registryPath, "utf8"));
 const baseSiteConfig = JSON.parse(fs.readFileSync("defaults/v8s-site-config.json", "utf8"));
 const customSiteConfigPath = "custom/v8s-site-config.json";

scripts/validate-lnk.mjs

@@ -103,7 +103,11 @@ if (!fs.existsSync(file)) {
 
     const segments = path.split("/");
     for (const segment of segments) {
-      if (!validSegment(segment)) fail(`${displayPath}: invalid segment '${segment}'`);
+      if (!validSegment(segment)) {
+        fail(
+          `${displayPath}: invalid segment '${segment}'; use ASCII letters, digits, dot, underscore, tilde, or hyphen`
+        );
+      }
     }
 
     if (reservedTopLevel.has(segments[0])) fail(`${displayPath}: top-level path '${segments[0]}' is reserved`);

scripts/validate-registry.mjs

@@ -54,6 +54,10 @@ function isValidPathTarget(value) {
   return typeof value === "string" && value.startsWith("/") && !value.startsWith("//");
 }
 
+function isValidSlugSegment(segment) {
+  return /^[A-Za-z0-9][A-Za-z0-9._~-]*$/.test(segment);
+}
+
 function isObject(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -96,6 +100,15 @@ function validateLink(link, prefix, blocklistPolicy, errors, seen = null) {
     error(errors, `${prefix}.slug is invalid: ${link.slug}`);
   }
 
+  for (const segment of link.slug.split("/")) {
+    if (!isValidSlugSegment(segment)) {
+      error(
+        errors,
+        `${prefix}.slug contains invalid segment "${segment}"; use ASCII letters, digits, dot, underscore, tilde, or hyphen`
+      );
+    }
+  }
+
   const match = link.match || "exact";
   if (!["exact", "splat"].includes(match)) {
     error(errors, `${prefix}.match must be exact or splat`);