create-avalon 0.1.14 → 0.1.16

package/README.md

@@ -1,59 +1,59 @@
-# create-avalon
-
-Scaffold a new [Avalon](https://useavalon.dev) project in seconds.
-
-## Usage
-
-```bash
-npm create avalon@latest
-```
-
-Or with other package managers:
-
-```bash
-pnpm create avalon@latest
-yarn create avalon
-bun create avalon
-```
-
-The CLI walks you through:
-
-- Project name and directory
-- Framework selection (React, Preact, Vue, Svelte, Solid, Lit, Qwik — or multiple)
-- Styling approach (CSS Modules, Tailwind, vanilla CSS)
-- Optional features (API routes, middleware, layouts, MDX)
-- Package manager preference
-
-## What you get
-
-A ready-to-run Avalon project with file-system routing, islands architecture, and zero JavaScript by default.
-
-```
-my-project/
-├── app/
-│   ├── modules/
-│   │   └── home/
-│   │       ├── pages/          # File-system routes
-│   │       ├── components/     # Interactive components
-│   │       └── layouts/        # Module layouts
-│   └── shared/
-│       ├── layouts/            # Root layout
-│       ├── components/         # Shared components
-│       └── styles/             # Global styles & tokens
-├── middleware/                  # Server middleware
-├── routes/
-│   └── api/                    # API routes
-├── server/                     # Server config & env
-├── public/                     # Static assets
-├── vite.config.ts
-└── package.json
-```
-
-## Links
-
-- [Documentation](https://useavalon.dev/docs/introduction)
-- [GitHub](https://github.com/useAvalon/Avalon)
-
-## License
-
-MIT
+# create-avalon
+
+Scaffold a new [Avalon](https://useavalon.dev) project in seconds.
+
+## Usage
+
+```bash
+npm create avalon@latest
+```
+
+Or with other package managers:
+
+```bash
+pnpm create avalon@latest
+yarn create avalon
+bun create avalon
+```
+
+The CLI walks you through:
+
+- Project name and directory
+- Framework selection (React, Preact, Vue, Svelte, Solid, Lit, Qwik — or multiple)
+- Styling approach (CSS Modules, Tailwind, vanilla CSS)
+- Optional features (API routes, middleware, layouts, MDX)
+- Package manager preference
+
+## What you get
+
+A ready-to-run Avalon project with file-system routing, islands architecture, and zero JavaScript by default.
+
+```
+my-project/
+├── app/
+│   ├── modules/
+│   │   └── home/
+│   │       ├── pages/          # File-system routes
+│   │       ├── components/     # Interactive components
+│   │       └── layouts/        # Module layouts
+│   └── shared/
+│       ├── layouts/            # Root layout
+│       ├── components/         # Shared components
+│       └── styles/             # Global styles & tokens
+├── middleware/                  # Server middleware
+├── routes/
+│   └── api/                    # API routes
+├── server/                     # Server config & env
+├── public/                     # Static assets
+├── vite.config.ts
+└── package.json
+```
+
+## Links
+
+- [Documentation](https://useavalon.dev/docs/introduction)
+- [GitHub](https://github.com/useAvalon/Avalon)
+
+## License
+
+MIT

package/dist/cli.js

@@ -1181,12 +1181,24 @@ async function collectProjectConfig(initialName) {
     Nt("Operation cancelled.");
     process.exit(1);
   }
+  const deployResult = await Jt({
+    message: "Where will you deploy?",
+    options: [
+      { value: "netlify", label: "Netlify", hint: "Generates netlify.toml, build.mjs, post-build.mjs" },
+      { value: "none", label: "None / Other", hint: "Node server preset, no deploy config" }
+    ]
+  });
+  if (Ct(deployResult)) {
+    Nt("Operation cancelled.");
+    process.exit(1);
+  }
   return {
     projectName,
     integrations: integrationsResult,
     styling: stylingResult,
     plugins: pluginsResult,
-    middleware: middlewareResult
+    middleware: middlewareResult,
+    deploy: deployResult
   };
 }
 
@@ -1264,12 +1276,17 @@ function generatePackageJson(config) {
     private: true,
     scripts: {
       dev: "bunx --bun vite dev",
-      build: "bunx --bun vite build",
-      preview: "bunx --bun vite preview"
+      build: config.deploy === "netlify" ? "bun build.mjs" : "bunx --bun vite build",
+      "post-build": config.deploy === "netlify" ? "node post-build.mjs" : undefined,
+      preview: "node .output/server/index.mjs"
     },
     dependencies,
     devDependencies
   };
+  for (const key of Object.keys(pkg.scripts)) {
+    if (pkg.scripts[key] === undefined)
+      delete pkg.scripts[key];
+  }
   return JSON.stringify(pkg, null, 2);
 }
 
@@ -1352,8 +1369,13 @@ function generateViteConfig(config) {
     `    layoutsDir: 'app/shared/layouts',`,
     `    image: true,`,
     `    nitro: {`,
-    `      preset: 'node_server',`,
+    `      preset: process.env.NITRO_PRESET || 'node_server',`,
     `      streaming: true,`,
+    `      prerender: {`,
+    `        routes: ['/'],`,
+    `        crawlLinks: true,`,
+    `        ignore: [],`,
+    `      },`,
     `    },`,
     `  });`,
     "",
@@ -1699,6 +1721,328 @@ function getFaviconBuffer() {
   return Buffer.from(FAVICON_BASE64, "base64");
 }
 
+// src/templates/deploy.ts
+function generateNetlifyToml(config) {
+  return `[build]
+  base = "."
+  command = "bun install && bun build.mjs"
+  publish = "dist"
+
+[build.environment]
+  NODE_VERSION = "22"
+  BUN_VERSION = "latest"
+  NITRO_PRESET = "netlify"
+
+[functions]
+  directory = "netlify/functions"
+`;
+}
+function generateBuildMjs() {
+  return `/**
+ * Netlify build wrapper.
+ *
+ * Vite/Nitro leaves open handles after the build completes, preventing
+ * the Node process from exiting. This wrapper detects when the build
+ * output is ready, kills the entire process group, then runs post-build.
+ */
+
+import { spawn, execSync } from 'node:child_process';
+import { existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+
+const CWD = process.cwd();
+const NITRO_JSON = join(CWD, '.netlify', 'functions-internal', 'nitro.json');
+const SERVER_MJS = join(CWD, '.netlify', 'functions-internal', 'server', 'server.mjs');
+const OUTPUT_SSR = join(CWD, '.output', 'server', '_ssr', 'ssr.mjs');
+
+console.log('[build] Starting vite build...');
+
+for (const dir of ['.netlify', '.output', 'netlify']) {
+  const full = join(CWD, dir);
+  if (existsSync(full)) {
+    rmSync(full, { recursive: true, force: true });
+    console.log(\`[build] Cleaned stale \${dir}/\`);
+  }
+}
+
+const child = spawn('bunx', ['--bun', 'vite', 'build'], {
+  cwd: CWD,
+  stdio: 'inherit',
+  detached: true,
+});
+
+const childPid = child.pid;
+let done = false;
+
+function killTree() {
+  try { process.kill(-childPid, 'SIGKILL'); } catch {}
+  try { child.kill('SIGKILL'); } catch {}
+}
+
+function finish() {
+  if (done) return;
+  done = true;
+  clearInterval(poll);
+  clearTimeout(absoluteTimeout);
+  killTree();
+
+  setTimeout(() => {
+    console.log('[build] Running post-build...');
+    try {
+      execSync('node post-build.mjs', { cwd: CWD, stdio: 'inherit', timeout: 120_000 });
+    } catch (err) {
+      console.error('[build] post-build warning:', err.message);
+    }
+
+    const V1_SERVER = join(CWD, '.netlify', 'v1', 'functions', 'server', 'server.mjs');
+    if (existsSync(V1_SERVER)) console.log('[build] ✅ Server function found (v1 API)');
+    else if (existsSync(SERVER_MJS)) console.log('[build] ✅ Server function found (legacy)');
+    else if (existsSync(OUTPUT_SSR)) console.log('[build] ✅ SSR bundle found');
+    else console.error('[build] ❌ No server output found');
+
+    console.log('[build] ✅ Complete');
+    process.exit(0);
+  }, 500);
+}
+
+child.on('exit', (code) => {
+  console.log(\`[build] vite build exited with code \${code}\`);
+  finish();
+});
+
+child.on('error', (err) => {
+  console.error('[build] spawn error:', err);
+  process.exit(1);
+});
+
+const poll = setInterval(() => {
+  const netlifyReady = existsSync(NITRO_JSON) && existsSync(SERVER_MJS);
+  const nodeServerReady = existsSync(OUTPUT_SSR);
+  if (netlifyReady || nodeServerReady) {
+    console.log(\`[build] Output detected (\${netlifyReady ? 'netlify' : 'node-server'}), waiting 3s for final writes...\`);
+    clearInterval(poll);
+    setTimeout(finish, 3_000);
+  }
+}, 1_000);
+
+const absoluteTimeout = setTimeout(() => {
+  console.error('[build] Timeout — killing build');
+  finish();
+}, 240_000);
+`;
+}
+
+// src/templates/post-build.ts
+function generatePostBuildMjs() {
+  const lines = [
+    `/**`,
+    ` * Post-build script for Netlify deployment.`,
+    ` *`,
+    ` * - Removes stale index.html that would shadow SSR routes`,
+    ` * - Generates _redirects for island JS path mapping`,
+    ` * - Copies island JS to clean paths for local preview`,
+    ` * - Copies server function to all Netlify function paths`,
+    ` * - Ensures SSR catch-all redirect exists`,
+    ` */`,
+    ``,
+    `import {`,
+    `  existsSync, unlinkSync, readFileSync, writeFileSync,`,
+    `  readdirSync, copyFileSync, mkdirSync, cpSync,`,
+    `} from 'node:fs';`,
+    `import { join, dirname, relative } from 'node:path';`,
+    ``,
+    `const CWD = process.cwd();`,
+    `const DIST_DIR = join(CWD, 'dist');`,
+    `const ASSETS_DIR = join(CWD, 'dist', 'assets');`,
+    ``,
+    `function collectFiles(dir, predicate, result = []) {`,
+    `  if (!existsSync(dir)) return result;`,
+    `  for (const entry of readdirSync(dir, { withFileTypes: true })) {`,
+    `    const full = join(dir, entry.name);`,
+    `    if (entry.isDirectory()) collectFiles(full, predicate, result);`,
+    `    else if (predicate(entry.name)) result.push(full);`,
+    `  }`,
+    `  return result;`,
+    `}`,
+    ``,
+    `function toServePath(absPath) {`,
+    `  return '/' + relative(DIST_DIR, absPath).replaceAll('\\\\', '/');`,
+    `}`,
+    ``,
+    `// ── Cleanup stale index.html ─────────────────────────────────────`,
+    `for (const htmlPath of ['dist/index.html', '.netlify/functions-internal/server/public/index.html']) {`,
+    `  const full = join(CWD, htmlPath);`,
+    `  if (existsSync(full)) { unlinkSync(full); console.log('[cleanup] Removed ' + htmlPath); }`,
+    `}`,
+    ``,
+    `// ── Generate island redirects + local copies ─────────────────────`,
+    `function generateIslandRedirects() {`,
+    `  const islandsDir = join(ASSETS_DIR, 'islands');`,
+    `  if (!existsSync(islandsDir)) return;`,
+    `  const islandFiles = collectFiles(islandsDir, n => n.endsWith('.js') && !n.endsWith('.js.map'));`,
+    `  if (islandFiles.length === 0) return;`,
+    `  const redirectLines = [];`,
+    `  for (const absPath of islandFiles) {`,
+    `    const servePath = toServePath(absPath);`,
+    `    const cleanPath = servePath.replace('/assets/', '/').replace(/-[A-Za-z0-9_-]{6,12}\\.js$/, '.js');`,
+    `    redirectLines.push(cleanPath + '  ' + servePath + '  200');`,
+    `    const cleanAbsPath = join(DIST_DIR, cleanPath.slice(1));`,
+    `    mkdirSync(dirname(cleanAbsPath), { recursive: true });`,
+    `    copyFileSync(absPath, cleanAbsPath);`,
+    `  }`,
+    `  const redirectsPath = join(DIST_DIR, '_redirects');`,
+    `  let existing = existsSync(redirectsPath) ? readFileSync(redirectsPath, 'utf-8') : '';`,
+    `  existing = existing.replaceAll(/# Island JS path rewrites[^\\n]*\\n(?:\\/islands\\/[^\\n]*\\n)*/g, '').trim();`,
+    `  const header = '# Island JS path rewrites (generated by post-build.mjs)\\n';`,
+    `  const content = existing`,
+    `    ? existing + '\\n\\n' + header + redirectLines.join('\\n') + '\\n'`,
+    `    : header + redirectLines.join('\\n') + '\\n';`,
+    `  writeFileSync(redirectsPath, content);`,
+    `  console.log('[redirects] Wrote ' + redirectLines.length + ' island redirects');`,
+    `}`,
+    ``,
+    `// ── Copy framework adapters ───────────────────────────────────────`,
+    `function copyAdapters() {`,
+    `  const sources = [`,
+    `    join(CWD, '.output', 'public', '_adapters'),`,
+    `    join(CWD, 'dist', '_adapters'),`,
+    `  ];`,
+    `  for (const srcDir of sources) {`,
+    `    if (!existsSync(srcDir)) continue;`,
+    `    const files = readdirSync(srcDir).filter(f => f.endsWith('.js'));`,
+    `    if (files.length === 0) continue;`,
+    `    const destDir = join(DIST_DIR, '_adapters');`,
+    `    mkdirSync(destDir, { recursive: true });`,
+    `    for (const file of files) {`,
+    `      const src = join(srcDir, file);`,
+    `      const dest = join(destDir, file);`,
+    `      if (src !== dest) copyFileSync(src, dest);`,
+    `    }`,
+    `    console.log('[adapters] Copied ' + files.length + ' framework adapters');`,
+    `    return;`,
+    `  }`,
+    `}`,
+    ``,
+    `// ── Copy function to all Netlify paths ────────────────────────────`,
+    `function copyToNetlifyPaths() {`,
+    `  const legacyDir = join(CWD, '.netlify', 'functions-internal', 'server');`,
+    `  if (!existsSync(legacyDir)) return;`,
+    `  const targets = [`,
+    `    join(CWD, '.netlify', 'v1', 'functions', 'server'),`,
+    `    join(CWD, 'netlify', 'functions', 'server'),`,
+    `  ];`,
+    `  for (const target of targets) {`,
+    `    cpSync(legacyDir, target, { recursive: true, force: true });`,
+    `  }`,
+    `  console.log('[netlify-fn] Copied server function to all Netlify paths');`,
+    `}`,
+    ``,
+    `// ── Ensure SSR catch-all redirect ─────────────────────────────────`,
+    `function ensureNetlifyRedirects() {`,
+    `  const redirectsPath = join(DIST_DIR, '_redirects');`,
+    `  let content = existsSync(redirectsPath) ? readFileSync(redirectsPath, 'utf-8') : '';`,
+    `  if (content.includes('/.netlify/functions/server')) return;`,
+    `  const catchAll = '\\n# SSR catch-all (Nitro server function)\\n/*  /.netlify/functions/server  200\\n';`,
+    `  content = content.trimEnd() + '\\n' + catchAll;`,
+    `  writeFileSync(redirectsPath, content);`,
+    `  console.log('[redirects] Added SSR catch-all to _redirects');`,
+    `}`,
+    ``,
+    `// ── Run ──────────────────────────────────────────────────────────`,
+    `(async () => {`,
+    ``,
+    `generateIslandRedirects();`,
+    `copyAdapters();`,
+    `copyToNetlifyPaths();`,
+    `ensureNetlifyRedirects();`,
+    ``,
+    `// ── Prerender (SSG) ──────────────────────────────────────────────`,
+    `// Spawn the built server and fetch routes to generate static HTML.`,
+    `const serverEntries = [`,
+    `  join(CWD, '.output', 'server', 'index.mjs'),`,
+    `  join(CWD, '.netlify', 'functions-internal', 'server', 'server.mjs'),`,
+    `  join(CWD, '.netlify', 'v1', 'functions', 'server', 'server.mjs'),`,
+    `];`,
+    `const serverEntry = serverEntries.find(p => existsSync(p));`,
+    `const outputDir = [join(CWD, '.output', 'public'), DIST_DIR].find(d => existsSync(d));`,
+    ``,
+    `if (serverEntry && outputDir) {`,
+    `  const { spawn: spawnProcess } = await import('node:child_process');`,
+    `  const PORT = 13172;`,
+    `  const baseUrl = 'http://localhost:' + PORT;`,
+    `  console.log('[prerender] Spawning server on port ' + PORT + '...');`,
+    `  const srv = spawnProcess('node', [serverEntry], {`,
+    `    env: { ...process.env, PORT: String(PORT), NITRO_PORT: String(PORT), HOST: '127.0.0.1', NITRO_HOST: '127.0.0.1', NODE_ENV: 'production' },`,
+    `    stdio: ['ignore', 'pipe', 'pipe'],`,
+    `  });`,
+    `  srv.stdout?.on('data', d => { const m = d.toString().trim(); if (m) console.log('[prerender:server] ' + m); });`,
+    `  srv.stderr?.on('data', d => { const m = d.toString().trim(); if (m) console.error('[prerender:server:err] ' + m); });`,
+    `  let ready = false;`,
+    `  const t0 = Date.now();`,
+    `  while (Date.now() - t0 < 15000) {`,
+    `    try { const r = await fetch(baseUrl + '/'); if (r.ok || r.status < 500) { ready = true; break; } } catch {}`,
+    `    await new Promise(r => setTimeout(r, 200));`,
+    `  }`,
+    `  if (ready) {`,
+    `    console.log('[prerender] Server ready');`,
+    `    const visited = new Set();`,
+    `    const queue = ['/'];`,
+    `    const prerendered = [];`,
+    `    while (queue.length > 0) {`,
+    `      const batch = queue.splice(0, 4);`,
+    `      await Promise.all(batch.map(async (route) => {`,
+    `        const norm = route.endsWith('/') && route !== '/' ? route.slice(0, -1) : route;`,
+    `        if (visited.has(norm)) return;`,
+    `        visited.add(norm);`,
+    `        try {`,
+    `          const res = await fetch(baseUrl + norm);`,
+    `          if (!res.ok) { console.error('[prerender] ' + norm + ' returned ' + res.status); return; }`,
+    `          const html = await res.text();`,
+    `          const fileName = join(norm, 'index.html');`,
+    `          const out = join(outputDir, fileName);`,
+    `          mkdirSync(dirname(out), { recursive: true });`,
+    `          writeFileSync(out, html);`,
+    `          prerendered.push(norm);`,
+    `          console.log('[prerender] ' + norm);`,
+    `          // Crawl links`,
+    `          const re = /<a\\s[^>]*href=["']([^"'#?]+)/gi;`,
+    `          let m;`,
+    `          while ((m = re.exec(html)) !== null) {`,
+    `            const href = m[1];`,
+    `            if (href.startsWith('/') && !href.startsWith('//') && !href.startsWith('/assets/') && !href.startsWith('/islands/') && !href.match(/\\.\\w{2,5}$/)) {`,
+    `              const n = href.endsWith('/') && href !== '/' ? href.slice(0, -1) : href;`,
+    `              if (!visited.has(n)) queue.push(n);`,
+    `            }`,
+    `          }`,
+    `        } catch (err) { console.error('[prerender] Error fetching ' + norm + ':', err.message); }`,
+    `      }));`,
+    `    }`,
+    `    srv.kill('SIGKILL');`,
+    `    console.log('[prerender] Done: ' + prerendered.length + ' page(s)');`,
+    `    // Copy to alt output dirs`,
+    `    for (const alt of [DIST_DIR, join(CWD, '.netlify', 'v1', 'functions', 'server', 'public')].filter(d => d !== outputDir && existsSync(dirname(d)))) {`,
+    `      for (const route of prerendered) {`,
+    `        const f = join(route, 'index.html');`,
+    `        const src = join(outputDir, f);`,
+    `        const dest = join(alt, f);`,
+    `        if (existsSync(src)) { mkdirSync(dirname(dest), { recursive: true }); copyFileSync(src, dest); }`,
+    `      }`,
+    `    }`,
+    `  } else {`,
+    `    srv.kill('SIGKILL');`,
+    `    console.error('[prerender] Server did not start, skipping prerender');`,
+    `  }`,
+    `}`,
+    ``,
+    `console.log('[post-build] Complete');`,
+    ``,
+    `})().catch(err => { console.error('[post-build] Fatal:', err); process.exit(1); });`,
+    ``
+  ];
+  return lines.join(`
+`);
+}
+
 // src/scaffold.ts
 function generateHonoServerEntry() {
   return `import { Hono } from 'hono';
@@ -1784,22 +2128,11 @@ async function scaffoldProject(config, targetDir) {
     ``
   ].join(`
 `));
-  await writeFile(join(targetDir, "index.html"), [
-    `<!DOCTYPE html>`,
-    `<html lang="en">`,
-    `  <head>`,
-    `    <meta charset="utf-8" />`,
-    `    <meta name="viewport" content="width=device-width, initial-scale=1" />`,
-    `    <title>Avalon</title>`,
-    `  </head>`,
-    `  <body>`,
-    `    <!--ssr-outlet-->`,
-    `    <script type="module" src="/src/client/main.js"></script>`,
-    `  </body>`,
-    `</html>`,
-    ``
-  ].join(`
-`));
+  if (config.deploy === "netlify") {
+    await writeFile(join(targetDir, "netlify.toml"), generateNetlifyToml(config));
+    await writeFile(join(targetDir, "build.mjs"), generateBuildMjs());
+    await writeFile(join(targetDir, "post-build.mjs"), generatePostBuildMjs());
+  }
 }
 
 // src/summary.ts
@@ -1808,10 +2141,15 @@ var STYLING_LABELS = {
   tailwind: "Tailwind CSS",
   shadcn: "shadcn"
 };
+var DEPLOY_LABELS = {
+  netlify: "Netlify",
+  none: "None"
+};
 function formatSummary(config, scaffoldedInPlace = false) {
   const integrations = config.integrations.length > 0 ? config.integrations.join(", ") : "none";
   const styling = STYLING_LABELS[config.styling] ?? config.styling;
   const plugins = config.plugins.length > 0 ? config.plugins.join(", ") : "none";
+  const deploy = DEPLOY_LABELS[config.deploy] ?? config.deploy;
   const nextSteps = scaffoldedInPlace ? ["    bun install", "    bun run dev"] : [`    cd ${config.projectName}`, "    bun install", "    bun run dev"];
   return [
     "",
@@ -1820,6 +2158,7 @@ function formatSummary(config, scaffoldedInPlace = false) {
     `  Styling:        ${styling}`,
     `  Plugins:        ${plugins}`,
     `  Middleware:     ${config.middleware}`,
+    `  Deploy:        ${deploy}`,
     "",
     "  Next steps:",
     ...nextSteps,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "create-avalon",
-	"version": "0.1.14",
+	"version": "0.1.16",
 	"description": "Scaffold a new Avalon project with multi-framework islands architecture",
 	"license": "MIT",
 	"type": "module",