nowebcli 0.2.16 → 0.2.18

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nowebcli",
-  "version": "0.2.16",
-  "description": "Create, preview and publish community templates for Noweb",
+  "version": "0.2.18",
+  "description": "Create, preview and upload community templates for Noweb",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -38,7 +38,6 @@
     "screenshots": "tsx scripts/generate-template-screenshots.ts",
     "fonts:update": "node --import tsx scripts/download-template-fonts.mjs",
     "template": "node scripts/noweb.mjs",
-    "template:publish": "node --env-file-if-exists=.env --env-file-if-exists=.env.local scripts/noweb.mjs publish",
     "migrate": "node --env-file-if-exists=.env --env-file-if-exists=.env.local --import tsx scripts/migrate-database.ts",
     "migrate:project-data": "node --env-file-if-exists=.env --env-file-if-exists=.env.local --import tsx scripts/migrate-project-data.ts",
     "ci": "npm audit --omit=dev --audit-level=high && npm run typecheck && npm run lint && npm run test && npm run build && npm run test:e2e"

package/scripts/noweb.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { spawn, spawnSync } from "node:child_process";
-import { createHash, randomBytes } from "node:crypto";
+import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
 import { createServer } from "node:http";
 import { access, chmod, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
@@ -17,11 +17,10 @@ const root = process.cwd();
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const engineRoot = existsSync(join(root, "templates/templateCompiler.ts")) ? root : packageRoot;
 const repositoryTemplatesRoot = join(root, "templates");
-const types = new Set(["portfolio", "app", "business", "other"]);
 const maxAssetBytes = 20 * 1024 * 1024;
 const maxAssetsBytes = 50 * 1024 * 1024;
 const cliArgs = process.argv.slice(2);
-const [command = "help", slug] = cliArgs.filter((argument) => !argument.startsWith("--"));
+const [command = "help", selection] = cliArgs.filter((argument) => !argument.startsWith("--"));
 const shouldInstall = !cliArgs.includes("--no-install");
 const dryRun = cliArgs.includes("--dry-run");
 const apiBase = (process.env.NOWEB_URL || "https://noweb.app").replace(/\/$/, "");
@@ -45,22 +44,21 @@ function success(message) {
 function usage() {
   console.log(`noweb
 
-  create [slug]   scaffold the current folder
-  reset [slug]    reset template files and public/; keep dependencies (--yes)
+  create          scaffold the current folder
+  reset           reset template files and public/; keep dependencies (--yes)
   setup           install local React and TypeScript dependencies
   dev             preview at http://127.0.0.1:4173
   check           validate and compile this template
   cover           create public/cover.jpg locally (1920×1080; --force to replace)
   login           connect the CLI to your Noweb account
   list            list your uploaded templates
-  download <slug>    restore one into the current folder
+  download <id>   restore one into the current folder
   upload          save this template without publishing
-  delete [slug]   delete one of your templates
-  publish         make the uploaded template public`);
+  delete [id]   delete one of your templates`);
 }
 
 async function createTemplate(value, install = shouldInstall) {
-  const validSlug = requireSlug(value || `template-${randomBytes(6).toString("hex")}`);
+  if (value) throw new Error(`Manage template names and slugs on ${apiBase}/account.`);
   const directory = root;
 
   for (const file of ["Template.tsx", "customizations.json", "template.json"]) {
@@ -69,13 +67,13 @@ async function createTemplate(value, install = shouldInstall) {
 
   await mkdir(join(directory, "public"), { recursive: true });
   await Promise.all([
-    writeFile(join(directory, "template.json"), `${JSON.stringify({ slug: validSlug, type: "other" }, null, 2)}\n`),
+    writeFile(join(directory, "template.json"), `${JSON.stringify({}, null, 2)}\n`),
     writeFile(join(directory, "Template.tsx"), starterTemplate),
     writeFile(join(directory, "customizations.json"), starterCustomizations),
     writeFile(join(directory, "public/.gitkeep"), ""),
   ]);
   await setupWorkspace(install);
-  success(`Created ${validSlug} in ${directory}. Add a 16:9 public/cover.jpg (JPEG, up to 5 MB).`);
+  success(`Created template in ${directory}. Add a 16:9 public/cover.jpg (JPEG, up to 5 MB).`);
 }
 
 async function resetTemplate(value) {
@@ -83,7 +81,7 @@ async function resetTemplate(value) {
   if (root === engineRoot || !files.every((file) => existsSync(join(root, file)))) {
     throw new Error("Run reset inside a template folder containing Template.tsx, customizations.json and template.json.");
   }
-  const validSlug = requireSlug(value || `template-${randomBytes(6).toString("hex")}`);
+  if (value) throw new Error(`Manage template names and slugs on ${apiBase}/account.`);
   if (!cliArgs.includes("--yes")) {
     if (!process.stdin.isTTY) throw new Error("Pass --yes to confirm resetting the template files and public/.");
     const prompt = createInterface({ input: process.stdin, output: process.stdout });
@@ -97,7 +95,7 @@ async function resetTemplate(value) {
   }
   progress.start("Resetting template files…");
   for (const file of [...files, "public"]) await rm(join(root, file), { recursive: true, force: true });
-  await createTemplate(validSlug, false);
+  await createTemplate(undefined, false);
 }
 
 async function setupWorkspace(install = true) {
@@ -116,37 +114,39 @@ async function setupWorkspace(install = true) {
 }
 
 async function checkRepositoryTemplates(value, quiet = false, assetRoot = "/assets") {
-  const slugs = value ? [requireSlug(value)] : await findTemplates();
-  if (!slugs.length) throw new Error("No templates with template.json found.");
+  const available = await findTemplates();
+  if (value && !available.includes(value)) throw new Error("Template folder not found.");
+  const folders = value ? [value] : available;
+  if (!folders.length) throw new Error("No templates with template.json found.");
 
   const results = [];
-  for (const currentSlug of slugs) {
-    const assetBase = assetRoot === "/assets" ? assetRoot : `${assetRoot}/${currentSlug}`;
-    if (!quiet) progress.start(`Compiling ${currentSlug}…`);
-    const result = await buildTemplate(join(repositoryTemplatesRoot, currentSlug), currentSlug, assetBase);
+  for (const folder of folders) {
+    const assetBase = assetRoot === "/assets" ? assetRoot : `${assetRoot}/${folder}`;
+    if (!quiet) progress.start(`Compiling ${folder}…`);
+    const result = await buildTemplate(join(repositoryTemplatesRoot, folder), assetBase);
     results.push(result);
-    if (!quiet) success(`✓ ${currentSlug} (${result.fields} fields, ${formatBytes(result.js.length + result.css.length)})`);
+    if (!quiet) success(`✓ ${folder} (${result.fields} fields, ${formatBytes(result.js.length + result.css.length)})`);
   }
   return results;
 }
 
-async function checkProject(quiet = false) {
+async function checkProject(quiet = false, requireCover = true) {
   if (!quiet) progress.start("Validating and compiling template…");
-  const result = await buildTemplate(root);
-  if (!quiet) success(`✓ ${result.slug} (${result.fields} fields, ${formatBytes(result.js.length + result.css.length)})`);
+  const result = await buildTemplate(root, "/assets", requireCover);
+  if (!quiet) success(`✓ Template (${result.fields} fields, ${formatBytes(result.js.length + result.css.length)})`);
   return result;
 }
 
-async function buildTemplate(directory, slugOverride, assetBase = "/assets", requireCover = true) {
+async function buildTemplate(directory, assetBase = "/assets", requireCover = true) {
   const [metadataSource, source, customizationsSource] = await Promise.all([
     readFile(join(directory, "template.json"), "utf8"),
     readFile(join(directory, "Template.tsx"), "utf8"),
     readFile(join(directory, "customizations.json"), "utf8"),
   ]);
   const metadata = JSON.parse(metadataSource);
-  const currentSlug = requireSlug(slugOverride || metadata?.slug);
-  if (!metadata || !types.has(metadata.type)) throw new Error(`${currentSlug}: template.json needs a type (${[...types].join(", ")}).`);
-  if (metadata.id != null && (!Number.isInteger(metadata.id) || metadata.id < 1)) throw new Error(`${currentSlug}: template.json has an invalid id.`);
+  const folder = basename(directory);
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) throw new Error("template.json must be an object with an optional id.");
+  if (metadata.id != null && (!Number.isInteger(metadata.id) || metadata.id < 1)) throw new Error(`${folder}: template.json has an invalid id.`);
 
   const [{ compileTemplateAssets }, { validateTemplateCode }, { validateTemplateCustomizations }] = await Promise.all([
     load("templates/templateCompiler.ts"),
@@ -159,9 +159,9 @@ async function buildTemplate(directory, slugOverride, assetBase = "/assets", req
     defaultValue: resolveAssetValue(field.defaultValue, assetBase),
   }));
   const ids = customizations.map((field) => field.fieldId);
-  if (new Set(ids).size !== ids.length) throw new Error(`${currentSlug}: customization field IDs must be unique.`);
+  if (new Set(ids).size !== ids.length) throw new Error(`${folder}: customization field IDs must be unique.`);
   for (const match of source.matchAll(/\bcustom\(\s*(\d+)\s*\)/g)) {
-    if (!ids.includes(Number(match[1]))) throw new Error(`${currentSlug}: custom(${match[1]}) has no customization.`);
+    if (!ids.includes(Number(match[1]))) throw new Error(`${folder}: custom(${match[1]}) has no customization.`);
   }
   const coverPath = join(directory, "public", "cover.jpg");
   let cover = null;
@@ -176,7 +176,7 @@ async function buildTemplate(directory, slugOverride, assetBase = "/assets", req
   for (const file of assetFiles) assetHash.update(file.path).update(file.body);
   const { js, css } = await compileTemplateAssets(source, customizations, assetBase);
   const versionedJs = assetFiles.length ? `${js}\n/* template-assets:${assetHash.digest("hex")} */` : js;
-  return { ...metadata, assetFiles, cover, css, customizations, fields: customizations.length, js: versionedJs, slug: currentSlug, source };
+  return { id: metadata.id, assetFiles, cover, css, customizations, fields: customizations.length, js: versionedJs, source };
 }
 
 async function createCover() {
@@ -184,7 +184,7 @@ async function createCover() {
   const force = cliArgs.includes("--force");
   if (!force && existsSync(coverPath)) throw new Error("public/cover.jpg already exists. Use `noweb cover --force` to replace it.");
   progress.start("Compiling cover preview…");
-  const template = await buildTemplate(root, undefined, "/assets", false);
+  const template = await buildTemplate(root, "/assets", false);
   const server = createServer(async (request, response) => {
     try {
       const pathname = new URL(request.url || "/", "http://127.0.0.1").pathname;
@@ -251,10 +251,10 @@ async function dev() {
     try {
       const url = new URL(request.url || "/", `http://${request.headers.host || "127.0.0.1"}`);
       if (url.pathname === "/") {
-        const template = await checkProject(true);
+        const template = await checkProject(true, false);
         response.writeHead(200, { "Cache-Control": "no-store", "Content-Type": "text/html; charset=utf-8" });
         response.end(previewHtml(template));
-        success(`✓ rebuilt ${template.slug}`);
+        success("✓ Rebuilt template");
         return;
       }
       await servePublic(url.pathname, response);
@@ -275,14 +275,12 @@ async function dev() {
 async function upload() {
   const template = await checkProject();
   if (dryRun) {
-    success(`Ready to upload ${template.slug}`);
+    success("Ready to upload template");
     return;
   }
 
   const credentials = await requireCredentials();
   const form = new FormData();
-  form.set("slug", template.slug);
-  form.set("type", template.type);
   if (template.id) form.set("id", String(template.id));
   form.set("source", template.source);
   form.set("customizations", JSON.stringify(template.customizations));
@@ -300,47 +298,31 @@ async function upload() {
   const result = await response.json().catch(() => ({}));
   if (!response.ok) throw new Error(result.error || `Upload failed (${response.status}).`);
   if (!Number.isInteger(result.id) || result.id < 1) throw new Error("Upload returned an invalid template ID.");
-  await writeFile(join(root, "template.json"), `${JSON.stringify({ id: result.id, slug: template.slug, type: template.type }, null, 2)}\n`);
-  success(`Uploaded ${template.slug} (${result.is_published ? "public" : "unpublished"}): ${new URL(result.url, apiBase)}`);
-}
-
-async function publishUploadedTemplate() {
-  const template = JSON.parse(await readFile(join(root, "template.json"), "utf8"));
-  if (!Number.isInteger(template.id) || template.id < 1) throw new Error("Upload this template first: npx nowebcli upload");
-  const credentials = await requireCredentials();
-  progress.start("Publishing template…");
-  const response = await fetch(`${apiBase}/api/templates/visibility`, {
-    method: "PATCH",
-    headers: { Authorization: `Bearer ${credentials.token}`, "Content-Type": "application/json" },
-    body: JSON.stringify({ id: template.id, published: true }),
-  });
-  const result = await response.json().catch(() => ({}));
-  if (!response.ok) throw new Error(result.error || `Publish failed (${response.status}).`);
-  success(`Published ${template.slug}: ${new URL(result.url, apiBase)}`);
+  await writeFile(join(root, "template.json"), `${JSON.stringify({ id: result.id }, null, 2)}\n`);
+  success(`Uploaded template #${result.id} (${result.is_published ? "public" : "unpublished"}): ${new URL(result.url, apiBase)}`);
 }
 
 async function deleteTemplate(value) {
   const metadata = value ? null : JSON.parse(await readFile(join(root, "template.json"), "utf8"));
-  const selectedSlug = requireSlug(value || metadata?.slug);
-  const selectedId = Number.isInteger(metadata?.id) && metadata.id > 0 ? metadata.id : null;
+  const selectedId = requireTemplateId(value ?? metadata?.id);
 
   if (!cliArgs.includes("--yes")) {
     if (!process.stdin.isTTY) throw new Error("Pass --yes to confirm deletion.");
     const prompt = createInterface({ input: process.stdin, output: process.stdout });
-    const answer = await prompt.question(`Delete ${selectedSlug} permanently? [y/N] `);
+    const answer = await prompt.question(`Delete template #${selectedId} permanently? [y/N] `);
     prompt.close();
     if (!/^y(?:es)?$/i.test(answer.trim())) return;
   }
 
   const credentials = await requireCredentials();
-  const selector = selectedId ? `id=${selectedId}` : `slug=${encodeURIComponent(selectedSlug)}`;
+  const selector = `id=${selectedId}`;
   const response = await fetch(`${apiBase}/api/templates/download?${selector}`, {
     method: "DELETE",
     headers: { Authorization: `Bearer ${credentials.token}` },
   });
   const result = await response.json().catch(() => ({}));
   if (!response.ok) throw new Error(result.error || `Delete failed (${response.status}).`);
-  success(`Deleted ${selectedSlug}`);
+  success(`Deleted template #${selectedId}`);
 }
 
 async function listTemplates() {
@@ -351,43 +333,34 @@ async function listTemplates() {
   const result = await response.json().catch(() => ({}));
   if (!response.ok) throw new Error(result.error || `Could not list templates (${response.status}).`);
   const templates = Array.isArray(result.templates) ? result.templates : [];
-  const projects = Array.isArray(result.projects) ? result.projects : [];
-  if (!templates.length && !projects.length) {
-    console.log("No templates or projects.");
+  if (!templates.length) {
+    console.log("No templates.");
     return;
   }
-  if (templates.length) {
-    console.log("Templates");
-    for (const template of templates) console.log(`${template.slug || template.id}\t${template.is_published ? "public" : "unpublished"}`);
-  }
-  if (projects.length) {
-    if (templates.length) console.log();
-    console.log("Projects");
-    for (const project of projects) console.log(`${project.id}\t${project.domain}`);
-  }
+  console.log("Templates");
+  for (const template of templates) console.log(`${template.id}\t${template.is_published ? "public" : "unpublished"}`);
 }
 
 async function downloadTemplate(value) {
-  const selectedSlug = requireSlug(value);
+  const selectedId = requireTemplateId(value);
   for (const file of ["Template.tsx", "customizations.json", "template.json"]) {
     if (existsSync(join(root, file))) throw new Error(`Template file already exists: ${file}`);
   }
 
   const credentials = await requireCredentials();
-  progress.start(`Downloading ${selectedSlug}…`);
-  const response = await fetch(`${apiBase}/api/templates/download?slug=${encodeURIComponent(selectedSlug)}`, {
+  progress.start(`Downloading template #${selectedId}…`);
+  const response = await fetch(`${apiBase}/api/templates/download?id=${selectedId}`, {
     headers: { Authorization: `Bearer ${credentials.token}` },
   });
   const result = await response.json().catch(() => ({}));
   if (!response.ok) throw new Error(result.error || `Download failed (${response.status}).`);
   const template = result.template;
   if (
-    !template || typeof template.metadata?.slug !== "string" ||
+    !template ||
     !Number.isInteger(template.metadata?.id) || template.metadata.id < 1 ||
-    !types.has(template.metadata?.type) || typeof template.source !== "string" ||
+    typeof template.source !== "string" ||
     !Array.isArray(template.customizations) || !Array.isArray(template.assets) || template.assets.length > 200
   ) throw new Error("The server returned an invalid template.");
-  const downloadedSlug = requireSlug(template.metadata.slug);
 
   const assets = await Promise.all(template.assets.map(async (asset) => {
     const path = requireAssetPath(asset?.path);
@@ -410,13 +383,13 @@ async function downloadTemplate(value) {
     await writeFile(destination, asset.body);
   }));
   await Promise.all([
-    writeFile(join(root, "template.json"), `${JSON.stringify(template.metadata, null, 2)}\n`),
+    writeFile(join(root, "template.json"), `${JSON.stringify({ id: template.metadata.id }, null, 2)}\n`),
     writeFile(join(root, "Template.tsx"), template.source),
     writeFile(join(root, "customizations.json"), `${JSON.stringify(template.customizations, null, 2)}\n`),
     ...(!assets.length ? [writeFile(join(root, "public/.gitkeep"), "")] : []),
   ]);
   await setupWorkspace(shouldInstall);
-  success(`Downloaded ${downloadedSlug} into ${root}`);
+  success(`Downloaded template #${selectedId} into ${root}`);
 }
 
 async function login() {
@@ -512,65 +485,6 @@ function wait(milliseconds) {
   return new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
 }
 
-async function publish(value) {
-  if (engineRoot !== root) throw new Error("Publishing is only available from the Noweb repository.");
-  const databaseUrl = process.env.DATABASE_POOL_URL ?? process.env.DATABASE_URL;
-  if (!databaseUrl) throw new Error("DATABASE_POOL_URL or DATABASE_URL is required to publish templates.");
-
-  const storageApi = await load("lib/object-storage.ts");
-  const storage = storageApi.getObjectStorageClientConfig();
-  const publicUrl = storageApi.getObjectStoragePublicUrl()?.replace(/\/$/, "");
-  if (!storage || !publicUrl) throw new Error("Object storage configuration is required to publish templates.");
-  const templates = await checkRepositoryTemplates(value, false, `${publicUrl}/template-assets`);
-  const { default: postgres } = await import("postgres");
-  const sql = postgres(databaseUrl, { connect_timeout: 10, max: 1 });
-
-  try {
-    for (const original of templates) {
-      const published = await sql.begin(async (transaction) => {
-        await transaction`SELECT pg_advisory_xact_lock(hashtextextended(${original.slug}, 0))`;
-        let [reserved] = await transaction`SELECT id FROM templates WHERE slug = ${original.slug} FOR UPDATE`;
-        if (!reserved) {
-          [reserved] = await transaction`
-            INSERT INTO templates (slug, type, component, compiled_js, compiled_css, customizations, author_id, is_published)
-            VALUES (${original.slug}, ${original.type}, ${original.source}, '', '', ${transaction.json(original.customizations)}, 'github', false) RETURNING id
-          `;
-        }
-        const { rewriteProjectAssetReferences } = await load("lib/project-template-snapshot.ts");
-        const template = { ...original, ...rewriteProjectAssetReferences(
-          { js: original.js, css: original.css, source: original.source, customizations: original.customizations },
-          new Map([[`${publicUrl}/template-assets/${original.slug}`, `${publicUrl}/templates/${reserved.id}`]]),
-        ) };
-        await uploadTemplateAssets(template, storageApi.createObjectStorageClient(storage), storage.bucketName, reserved.id);
-        const [updated] = await transaction`
-          UPDATE templates SET
-            type = ${template.type}, component = ${template.source},
-            compiled_js = ${template.js}, compiled_css = ${template.css},
-            customizations = ${transaction.json(template.customizations)}, is_published = true
-          WHERE id = ${reserved.id} AND (
-            type IS DISTINCT FROM ${template.type}
-            OR component IS DISTINCT FROM ${template.source}
-            OR compiled_js IS DISTINCT FROM ${template.js}
-            OR compiled_css IS DISTINCT FROM ${template.css}
-            OR customizations::jsonb IS DISTINCT FROM ${transaction.json(template.customizations)}::jsonb
-            OR is_published IS DISTINCT FROM true
-          )
-          RETURNING id
-        `;
-        return updated;
-      });
-      if (!published) {
-        console.log(`Unchanged ${original.slug}`);
-        continue;
-      }
-      await (await load("lib/template-screenshot.ts")).generateTemplatePreview(Number(published.id));
-      success(`Published ${original.slug} as template ${published.id}`);
-    }
-  } finally {
-    await sql.end({ timeout: 5 });
-  }
-}
-
 async function findTemplates() {
   const entries = await readdir(repositoryTemplatesRoot, { withFileTypes: true });
   return entries
@@ -651,30 +565,15 @@ function resolveAssetValue(value, assetBase) {
   return value;
 }
 
-async function uploadTemplateAssets(template, client, bucketName, templateId) {
-  const { PutObjectCommand } = await import("@aws-sdk/client-s3");
-  for (const file of template.assetFiles) {
-    await client.send(new PutObjectCommand({
-      Bucket: bucketName,
-      Key: `templates/${templateId}/${file.path}`,
-      Body: file.body,
-      CacheControl: "public, max-age=0, must-revalidate",
-      ContentType: mimeTypes[extname(file.path).toLowerCase()] || "application/octet-stream",
-    }));
-  }
-  await client.send(new PutObjectCommand({
-    Bucket: bucketName, Key: `template-previews/${templateId}.jpg`, Body: template.cover,
-    CacheControl: "public, max-age=0, must-revalidate", ContentType: "image/jpeg",
-  }));
-}
-
 function previewHtml(template) {
-  return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${escapeHtml(template.slug)}</title><style>${escapeClosingTag(template.css, "style")}</style></head><body><div id="root"></div><script>${escapeClosingTag(template.js, "script")}</script><script>window.__nowebRenderTemplate(document.getElementById("root"), {});</script></body></html>`;
+  return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Template preview</title><style>${escapeClosingTag(template.css, "style")}</style></head><body><div id="root"></div><script>${escapeClosingTag(template.js, "script")}</script><script>window.__nowebRenderTemplate(document.getElementById("root"), {});</script></body></html>`;
 }
 
-function requireSlug(value) {
-  if (!value || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value)) throw new Error("Use a lowercase template slug, for example: minimal-portfolio");
-  return value;
+function requireTemplateId(value) {
+  if (!/^[1-9]\d*$/.test(String(value)) || !Number.isSafeInteger(Number(value))) {
+    throw new Error("Use a template ID from `noweb list`.");
+  }
+  return Number(value);
 }
 
 function requireAssetPath(value) {
@@ -780,18 +679,18 @@ const workspaceTsconfig = {
 try {
   await access(join(engineRoot, "templates/templateCompiler.ts"));
 
-  if (command === "create") await createTemplate(slug);
-  else if (command === "reset") await resetTemplate(slug);
+  if (command === "create") await createTemplate(selection);
+  else if (command === "reset") await resetTemplate(selection);
   else if (command === "setup") await setupWorkspace(shouldInstall);
-  else if (command === "check") await (slug && engineRoot === root ? checkRepositoryTemplates(slug) : checkProject());
+  else if (command === "check") await (selection && engineRoot === root ? checkRepositoryTemplates(selection) : checkProject());
   else if (command === "dev") await dev();
   else if (command === "cover") await createCover();
   else if (command === "login") await login();
   else if (command === "list") await listTemplates();
-  else if (command === "download") await downloadTemplate(slug);
+  else if (command === "download") await downloadTemplate(selection);
   else if (command === "upload") await upload();
-  else if (command === "delete") await deleteTemplate(slug);
-  else if (command === "publish") await (engineRoot === root ? publish(slug) : publishUploadedTemplate());
+  else if (command === "delete") await deleteTemplate(selection);
+  else if (command === "publish") throw new Error(`Publish templates on the website: ${apiBase}/account`);
   else if (command === "help" || command === "--help" || command === "-h") usage();
   else throw new Error(`Unknown command: ${command}`);
 } catch (error) {

package/templates/templateCompiler.ts

@@ -13,8 +13,8 @@ import { validateTemplateCode } from "./validateTemplateCode.ts";
 const run = promisify(execFile);
 const templatesPath = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
-const esbuildPath = require.resolve("esbuild/bin/esbuild");
-const modulesPath = path.dirname(path.dirname(require.resolve("react/package.json")));
+const esbuildPath = require.resolve(/* turbopackIgnore: true */ "esbuild/bin/esbuild");
+const modulesPath = path.dirname(path.dirname(require.resolve(/* turbopackIgnore: true */ "react/package.json")));
 
 const TEMPLATE_COMPILE_TIMEOUT_MS = 10_000;
 const TEMPLATE_COMPILE_MAX_BUFFER = 8 * 1024 * 1024;
@@ -166,7 +166,7 @@ function runtimeAliases() {
   return [
     // npx and project dependencies must share the renderer's React instance.
     ...["react", "react-dom"].map((name) =>
-      `--alias:${name}=${path.dirname(require.resolve(`${name}/package.json`, { paths: [modulesPath] }))}`,
+      `--alias:${name}=${path.dirname(require.resolve(/* turbopackIgnore: true */ `${name}/package.json`, { paths: [modulesPath] }))}`,
     ),
     ...TEMPLATE_RUNTIME_IMPORTS.map(
     (moduleName) => `--alias:${moduleName}=${templateRuntimePath()}`,