create-avalon 0.1.13 → 0.1.15

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,7 +1369,7 @@ function generateViteConfig(config) {
     `    layoutsDir: 'app/shared/layouts',`,
     `    image: true,`,
     `    nitro: {`,
-    `      preset: 'node_server',`,
+    `      preset: process.env.NITRO_PRESET || 'node_server',`,
     `      streaming: true,`,
     `    },`,
     `  });`,
@@ -1699,6 +1716,245 @@ 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: 60_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 ──────────────────────────────────────────────────────────`,
+    `generateIslandRedirects();`,
+    `copyAdapters();`,
+    `copyToNetlifyPaths();`,
+    `ensureNetlifyRedirects();`,
+    `console.log('[post-build] Complete');`,
+    ``
+  ];
+  return lines.join(`
+`);
+}
+
 // src/scaffold.ts
 function generateHonoServerEntry() {
   return `import { Hono } from 'hono';
@@ -1763,30 +2019,32 @@ async function scaffoldProject(config, targetDir) {
   await writeFile(join(targetDir, "server/renderer.ts"), [
     `import { createNitroRenderer } from '@useavalon/avalon/nitro/renderer';`,
     `import avalonConfig from 'virtual:avalon/config';`,
+    `import { loadPage } from 'virtual:avalon/page-loader';`,
     ``,
     `export default createNitroRenderer({`,
     `  avalonConfig,`,
     `  isDev: avalonConfig.isDev,`,
+    `  resolvePageRoute: async (pathname) => {`,
+    `    const mod = loadPage(pathname);`,
+    `    if (!mod) return null;`,
+    `    return { filePath: \`[virtual:\${pathname}]\`, pattern: pathname, params: {} };`,
+    `  },`,
+    `  loadPageModule: async (filePath) => {`,
+    `    const match = filePath.match(/^\\[virtual:(.+)\\]$/);`,
+    `    const pathname = match ? match[1] : filePath;`,
+    `    const mod = loadPage(pathname);`,
+    `    if (mod) return mod;`,
+    `    return { default: () => null, metadata: { title: 'Avalon' } };`,
+    `  },`,
     `});`,
     ``
   ].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
@@ -1795,10 +2053,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 [
     "",
@@ -1807,6 +2070,7 @@ function formatSummary(config, scaffoldedInPlace = false) {
     `  Styling:        ${styling}`,
     `  Plugins:        ${plugins}`,
     `  Middleware:     ${config.middleware}`,
+    `  Deploy:        ${deploy}`,
     "",
     "  Next steps:",
     ...nextSteps,

package/package.json

@@ -1,39 +1,39 @@
-{
-	"name": "create-avalon",
-	"version": "0.1.13",
-	"description": "Scaffold a new Avalon project with multi-framework islands architecture",
-	"license": "MIT",
-	"type": "module",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/useAvalon/Avalon.git",
-		"directory": "packages/create-avalon"
-	},
-	"homepage": "https://useavalon.dev",
-	"keywords": [
-		"avalon",
-		"create",
-		"scaffold",
-		"cli",
-		"islands",
-		"vite"
-	],
-	"bin": {
-		"create-avalon": "dist/cli.js"
-	},
-	"files": [
-		"dist",
-		"README.md"
-	],
-	"scripts": {
-		"build": "bun build src/cli.ts --outdir dist --target node --format esm",
-		"prepublishOnly": "bun run build"
-	},
-	"dependencies": {
-		"@clack/prompts": "^1.1.0"
-	},
-	"devDependencies": {
-		"fast-check": "^4.6.0",
-		"vitest": "^4.1.0"
-	}
-}
+{
+	"name": "create-avalon",
+	"version": "0.1.15",
+	"description": "Scaffold a new Avalon project with multi-framework islands architecture",
+	"license": "MIT",
+	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/useAvalon/Avalon.git",
+		"directory": "packages/create-avalon"
+	},
+	"homepage": "https://useavalon.dev",
+	"keywords": [
+		"avalon",
+		"create",
+		"scaffold",
+		"cli",
+		"islands",
+		"vite"
+	],
+	"bin": {
+		"create-avalon": "dist/cli.js"
+	},
+	"files": [
+		"dist",
+		"README.md"
+	],
+	"scripts": {
+		"build": "bun build src/cli.ts --outdir dist --target node --format esm",
+		"prepublishOnly": "bun run build"
+	},
+	"dependencies": {
+		"@clack/prompts": "^1.1.0"
+	},
+	"devDependencies": {
+		"fast-check": "^4.6.0",
+		"vitest": "^4.1.0"
+	}
+}