blumenjs 0.2.2 → 0.2.3

package/dist/cli/commands/audit.js

@@ -0,0 +1,204 @@
+// cli/commands/audit.ts
+import { execSync } from "child_process";
+
+// cli/utils.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var log = {
+  info: (msg) => console.log(`  ${c.magenta}\u25CF${c.reset}  ${msg}`),
+  success: (msg) => console.log(`  ${c.green}\u2713${c.reset}  ${msg}`),
+  error: (msg) => console.error(`  ${c.red}\u2717${c.reset}  ${msg}`),
+  warn: (msg) => console.log(`  ${c.yellow}\u26A0${c.reset}  ${msg}`),
+  step: (msg) => console.log(`  ${c.dim}\u2192${c.reset}  ${msg}`),
+  blank: () => console.log("")
+};
+function getVersion() {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    let dir = path.dirname(thisFile);
+    for (let i = 0; i < 5; i++) {
+      const pkgFile = path.join(dir, "package.json");
+      if (fs.existsSync(pkgFile)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf-8"));
+        if (pkg.name === "blumenjs" || pkg.name === "go-react-ssr") {
+          return pkg.version;
+        }
+      }
+      dir = path.dirname(dir);
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function banner() {
+  const version = getVersion();
+  console.log("");
+  console.log(
+    `  ${c.magenta}${c.bold}\u{1F338} Blumen${c.reset} ${c.dim}v${version}${c.reset}`
+  );
+  console.log(
+    `  ${c.dim}The React framework powered by Go${c.reset}`
+  );
+  console.log("");
+}
+function divider() {
+  console.log(`  ${c.dim}${"\u2500".repeat(48)}${c.reset}`);
+}
+
+// cli/commands/audit.ts
+function severityColor(severity) {
+  switch (severity) {
+    case "critical":
+      return c.red;
+    case "high":
+      return c.red;
+    case "moderate":
+      return c.yellow;
+    case "low":
+      return c.dim;
+    default:
+      return c.dim;
+  }
+}
+function severityIcon(severity) {
+  switch (severity) {
+    case "critical":
+      return "\u{1F534}";
+    case "high":
+      return "\u{1F7E0}";
+    case "moderate":
+      return "\u{1F7E1}";
+    case "low":
+      return "\u{1F535}";
+    default:
+      return "\u26AA";
+  }
+}
+async function audit(args = []) {
+  banner();
+  const fix = args.includes("--fix");
+  const ci = args.includes("--ci");
+  const jsonOutput = args.includes("--json");
+  if (fix) {
+    log.info("Attempting to fix vulnerabilities...");
+    log.blank();
+    try {
+      execSync("npm audit fix", {
+        stdio: "inherit",
+        cwd: process.cwd()
+      });
+      log.blank();
+      log.success("Audit fix completed.");
+    } catch {
+      log.warn("Some vulnerabilities could not be fixed automatically.");
+      log.info(`Run ${c.bold}npm audit fix --force${c.reset} to force-fix (may include breaking changes).`);
+    }
+    return;
+  }
+  if (jsonOutput) {
+    try {
+      execSync("npm audit --json", {
+        stdio: "inherit",
+        cwd: process.cwd()
+      });
+    } catch {
+      process.exit(1);
+    }
+    return;
+  }
+  log.info("Scanning dependencies for known vulnerabilities...");
+  log.blank();
+  let auditOutput;
+  let hasVulnerabilities = false;
+  try {
+    auditOutput = execSync("npm audit --json 2>/dev/null", {
+      cwd: process.cwd(),
+      encoding: "utf-8"
+    });
+  } catch (err) {
+    auditOutput = err.stdout || "{}";
+    hasVulnerabilities = true;
+  }
+  try {
+    const report = JSON.parse(auditOutput);
+    const meta = report.metadata || {};
+    const vulns = meta.vulnerabilities || {
+      info: 0,
+      low: 0,
+      moderate: 0,
+      high: 0,
+      critical: 0,
+      total: 0
+    };
+    const deps = meta.dependencies || {};
+    const total = vulns.total || vulns.critical + vulns.high + vulns.moderate + vulns.low + (vulns.info || 0);
+    divider();
+    log.blank();
+    if (total === 0) {
+      log.success(`${c.bold}No vulnerabilities found!${c.reset} \u2728`);
+      log.blank();
+      if (deps.total) {
+        log.info(`Scanned ${c.bold}${deps.total}${c.reset} dependencies.`);
+      }
+    } else {
+      log.warn(`${c.bold}${total} vulnerabilit${total === 1 ? "y" : "ies"} found${c.reset}`);
+      log.blank();
+      const levels = [
+        { name: "critical", count: vulns.critical },
+        { name: "high", count: vulns.high },
+        { name: "moderate", count: vulns.moderate },
+        { name: "low", count: vulns.low }
+      ];
+      for (const level of levels) {
+        if (level.count > 0) {
+          const color = severityColor(level.name);
+          const icon = severityIcon(level.name);
+          console.log(`  ${icon}  ${color}${level.count} ${level.name}${c.reset}`);
+        }
+      }
+      log.blank();
+      if (deps.total) {
+        log.info(`Scanned ${c.bold}${deps.total}${c.reset} dependencies.`);
+      }
+      log.info(`Run ${c.bold}blumen audit --fix${c.reset} to attempt automatic fixes.`);
+    }
+    log.blank();
+    divider();
+    log.blank();
+    if (ci && (vulns.critical > 0 || vulns.high > 0)) {
+      log.error("CI check failed: high or critical vulnerabilities detected.");
+      process.exit(1);
+    }
+  } catch {
+    log.info("Detailed report:");
+    log.blank();
+    try {
+      execSync("npm audit", {
+        stdio: "inherit",
+        cwd: process.cwd()
+      });
+    } catch {
+      if (ci) {
+        process.exit(1);
+      }
+    }
+  }
+}
+export {
+  audit
+};

package/dist/cli/commands/bench.js

@@ -0,0 +1,227 @@
+// cli/commands/bench.ts
+import * as http from "http";
+
+// cli/utils.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var log = {
+  info: (msg) => console.log(`  ${c.magenta}\u25CF${c.reset}  ${msg}`),
+  success: (msg) => console.log(`  ${c.green}\u2713${c.reset}  ${msg}`),
+  error: (msg) => console.error(`  ${c.red}\u2717${c.reset}  ${msg}`),
+  warn: (msg) => console.log(`  ${c.yellow}\u26A0${c.reset}  ${msg}`),
+  step: (msg) => console.log(`  ${c.dim}\u2192${c.reset}  ${msg}`),
+  blank: () => console.log("")
+};
+function getVersion() {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    let dir = path.dirname(thisFile);
+    for (let i = 0; i < 5; i++) {
+      const pkgFile = path.join(dir, "package.json");
+      if (fs.existsSync(pkgFile)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf-8"));
+        if (pkg.name === "blumenjs" || pkg.name === "go-react-ssr") {
+          return pkg.version;
+        }
+      }
+      dir = path.dirname(dir);
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function banner() {
+  const version = getVersion();
+  console.log("");
+  console.log(
+    `  ${c.magenta}${c.bold}\u{1F338} Blumen${c.reset} ${c.dim}v${version}${c.reset}`
+  );
+  console.log(
+    `  ${c.dim}The React framework powered by Go${c.reset}`
+  );
+  console.log("");
+}
+function divider() {
+  console.log(`  ${c.dim}${"\u2500".repeat(48)}${c.reset}`);
+}
+
+// cli/commands/bench.ts
+function percentile(sorted, p) {
+  const idx = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, idx)];
+}
+function makeRequest(url) {
+  return new Promise((resolve, reject) => {
+    const start = performance.now();
+    const req = http.get(url, (res) => {
+      let body = "";
+      res.on("data", (chunk) => {
+        body += chunk;
+      });
+      res.on("end", () => {
+        resolve({
+          latency: performance.now() - start,
+          status: res.statusCode || 0,
+          cacheHeader: res.headers["x-blumen-cache"] || ""
+        });
+      });
+    });
+    req.on("error", reject);
+    req.setTimeout(1e4, () => {
+      req.destroy();
+      reject(new Error("Timeout"));
+    });
+  });
+}
+async function runBenchmark(url, totalRequests, concurrency) {
+  const latencies = [];
+  let successful = 0;
+  let failed = 0;
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  let streamed = 0;
+  let completed = 0;
+  const start = performance.now();
+  for (let i = 0; i < totalRequests; i += concurrency) {
+    const batchSize = Math.min(concurrency, totalRequests - i);
+    const batch = Array.from(
+      { length: batchSize },
+      () => makeRequest(url).then((result) => {
+        latencies.push(result.latency);
+        if (result.status >= 200 && result.status < 400) {
+          successful++;
+        } else {
+          failed++;
+        }
+        if (result.cacheHeader === "HIT" || result.cacheHeader === "STALE")
+          cacheHits++;
+        else if (result.cacheHeader === "MISS")
+          cacheMisses++;
+        else if (result.cacheHeader === "STREAM")
+          streamed++;
+        completed++;
+      }).catch(() => {
+        failed++;
+        completed++;
+      })
+    );
+    await Promise.all(batch);
+    const pct = Math.round(completed / totalRequests * 100);
+    process.stdout.write(`\r  \u25CF  Progress: ${pct}% (${completed}/${totalRequests})`);
+  }
+  process.stdout.write("\r" + " ".repeat(60) + "\r");
+  const totalTimeMs = performance.now() - start;
+  const sorted = latencies.sort((a, b) => a - b);
+  return {
+    url,
+    totalRequests,
+    successfulRequests: successful,
+    failedRequests: failed,
+    totalTimeMs,
+    requestsPerSec: successful / totalTimeMs * 1e3,
+    latencies: sorted,
+    p50: sorted.length ? percentile(sorted, 50) : 0,
+    p95: sorted.length ? percentile(sorted, 95) : 0,
+    p99: sorted.length ? percentile(sorted, 99) : 0,
+    min: sorted.length ? sorted[0] : 0,
+    max: sorted.length ? sorted[sorted.length - 1] : 0,
+    avg: sorted.length ? sorted.reduce((a, b) => a + b, 0) / sorted.length : 0,
+    cacheHits,
+    cacheMisses,
+    streamed
+  };
+}
+function formatMs(ms) {
+  if (ms < 1)
+    return `${(ms * 1e3).toFixed(0)}\xB5s`;
+  if (ms < 1e3)
+    return `${ms.toFixed(1)}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function printResult(result) {
+  console.log(`  ${c.bold}URL${c.reset}             ${result.url}`);
+  console.log(`  ${c.bold}Requests${c.reset}        ${result.successfulRequests}/${result.totalRequests} successful${result.failedRequests > 0 ? ` (${result.failedRequests} failed)` : ""}`);
+  console.log(`  ${c.bold}Duration${c.reset}        ${formatMs(result.totalTimeMs)}`);
+  console.log(`  ${c.bold}Throughput${c.reset}      ${c.green}${result.requestsPerSec.toFixed(1)} req/sec${c.reset}`);
+  console.log("");
+  console.log(`  ${c.bold}Latency${c.reset}`);
+  console.log(`    min         ${formatMs(result.min)}`);
+  console.log(`    avg         ${formatMs(result.avg)}`);
+  console.log(`    p50         ${formatMs(result.p50)}`);
+  console.log(`    p95         ${c.yellow}${formatMs(result.p95)}${c.reset}`);
+  console.log(`    p99         ${c.yellow}${formatMs(result.p99)}${c.reset}`);
+  console.log(`    max         ${formatMs(result.max)}`);
+  if (result.cacheHits > 0 || result.cacheMisses > 0 || result.streamed > 0) {
+    console.log("");
+    console.log(`  ${c.bold}Cache${c.reset}`);
+    if (result.cacheHits > 0)
+      console.log(`    HIT         ${result.cacheHits} (${(result.cacheHits / result.totalRequests * 100).toFixed(0)}%)`);
+    if (result.cacheMisses > 0)
+      console.log(`    MISS        ${result.cacheMisses}`);
+    if (result.streamed > 0)
+      console.log(`    STREAM      ${result.streamed}`);
+  }
+}
+async function bench(args = []) {
+  banner();
+  let baseUrl = "http://localhost:3000";
+  let totalRequests = 200;
+  let concurrency = 10;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--url" && args[i + 1]) {
+      baseUrl = args[++i];
+    } else if (args[i] === "--requests" && args[i + 1]) {
+      totalRequests = parseInt(args[++i], 10);
+    } else if (args[i] === "--concurrency" && args[i + 1]) {
+      concurrency = parseInt(args[++i], 10);
+    }
+  }
+  log.info(`Benchmarking ${c.bold}${baseUrl}${c.reset}`);
+  log.info(`${totalRequests} requests, ${concurrency} concurrent connections`);
+  log.blank();
+  divider();
+  const endpoints = [
+    { name: "Homepage (SSR)", path: "/" },
+    { name: "About (SSR)", path: "/about" },
+    { name: "Static Asset", path: "/static/js/runtime.js" }
+  ];
+  for (const endpoint of endpoints) {
+    const url = `${baseUrl}${endpoint.path}`;
+    log.blank();
+    console.log(`  ${c.bold}${c.cyan}\u25B8 ${endpoint.name}${c.reset}`);
+    log.blank();
+    try {
+      const result = await runBenchmark(url, totalRequests, concurrency);
+      printResult(result);
+    } catch (err) {
+      log.error(`  Failed to benchmark ${url}: ${err.message}`);
+      log.info(`  Make sure the server is running (${c.bold}blumen dev${c.reset} or ${c.bold}blumen start${c.reset})`);
+    }
+    log.blank();
+    divider();
+  }
+  log.blank();
+  log.success("Benchmark complete! \u2728");
+  log.blank();
+  log.info(`For production load testing, use k6:`);
+  log.info(`  ${c.bold}k6 run benchmarks/k6-load-test.js${c.reset}`);
+  log.blank();
+}
+export {
+  bench
+};

package/dist/cli/commands/export.js

@@ -0,0 +1,241 @@
+// cli/commands/export.ts
+import { execSync, spawn } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as http from "http";
+
+// cli/utils.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var log = {
+  info: (msg) => console.log(`  ${c.magenta}\u25CF${c.reset}  ${msg}`),
+  success: (msg) => console.log(`  ${c.green}\u2713${c.reset}  ${msg}`),
+  error: (msg) => console.error(`  ${c.red}\u2717${c.reset}  ${msg}`),
+  warn: (msg) => console.log(`  ${c.yellow}\u26A0${c.reset}  ${msg}`),
+  step: (msg) => console.log(`  ${c.dim}\u2192${c.reset}  ${msg}`),
+  blank: () => console.log("")
+};
+function getVersion() {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    let dir = path.dirname(thisFile);
+    for (let i = 0; i < 5; i++) {
+      const pkgFile = path.join(dir, "package.json");
+      if (fs.existsSync(pkgFile)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf-8"));
+        if (pkg.name === "blumenjs" || pkg.name === "go-react-ssr") {
+          return pkg.version;
+        }
+      }
+      dir = path.dirname(dir);
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function banner() {
+  const version = getVersion();
+  console.log("");
+  console.log(
+    `  ${c.magenta}${c.bold}\u{1F338} Blumen${c.reset} ${c.dim}v${version}${c.reset}`
+  );
+  console.log(
+    `  ${c.dim}The React framework powered by Go${c.reset}`
+  );
+  console.log("");
+}
+function divider() {
+  console.log(`  ${c.dim}${"\u2500".repeat(48)}${c.reset}`);
+}
+
+// cli/commands/export.ts
+async function renderPage(route, ssrUrl) {
+  const body = JSON.stringify({
+    path: route,
+    query: {},
+    params: {}
+  });
+  return new Promise((resolve2, reject) => {
+    const req = http.request(ssrUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body)
+      }
+    }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(data);
+          if (json.html) {
+            resolve2(json.html);
+          } else {
+            reject(new Error("SSR response missing html field"));
+          }
+        } catch {
+          reject(new Error(`Invalid SSR response: ${data.slice(0, 100)}`));
+        }
+      });
+    });
+    req.on("error", (err) => reject(new Error(`SSR server unreachable: ${err.message}`)));
+    req.setTimeout(15e3, () => {
+      req.destroy();
+      reject(new Error("SSR timeout"));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+function discoverRoutes() {
+  const pagesDir = path2.resolve("app/pages");
+  const routes = [];
+  function scan(dir, prefix) {
+    if (!fs2.existsSync(dir))
+      return;
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith("_") || entry.name.startsWith("."))
+        continue;
+      if (entry.isDirectory()) {
+        scan(path2.join(dir, entry.name), `${prefix}/${entry.name.toLowerCase()}`);
+      } else if (entry.name.endsWith(".tsx") && !entry.name.startsWith("NotFound")) {
+        const name = entry.name.replace(".tsx", "");
+        if (name.toLowerCase() === "home") {
+          routes.push("/");
+        } else if (name === "index") {
+          routes.push(prefix || "/");
+        } else if (!name.includes("[")) {
+          routes.push(`${prefix}/${name.toLowerCase()}`);
+        }
+      }
+    }
+  }
+  scan(pagesDir, "");
+  return routes;
+}
+async function waitForServer(url, maxWaitMs = 15e3) {
+  const start = Date.now();
+  while (Date.now() - start < maxWaitMs) {
+    try {
+      await new Promise((resolve2, reject) => {
+        const req = http.get(url, () => resolve2());
+        req.on("error", reject);
+        req.setTimeout(1e3, () => {
+          req.destroy();
+          reject(new Error("timeout"));
+        });
+      });
+      return true;
+    } catch {
+      await new Promise((r) => setTimeout(r, 500));
+    }
+  }
+  return false;
+}
+async function exportSite(args = []) {
+  banner();
+  let outDir = "dist/export";
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--out" && args[i + 1]) {
+      outDir = args[++i];
+    }
+  }
+  log.info("Exporting static site...");
+  log.blank();
+  log.info("Step 1/4: Building production bundle...");
+  try {
+    execSync("npx tsx cli/blumen.ts build", { stdio: "inherit", cwd: process.cwd() });
+  } catch {
+    log.error("Build failed. Fix errors and try again.");
+    process.exit(1);
+  }
+  log.blank();
+  log.info("Step 2/4: Starting SSR server for pre-rendering...");
+  const ssrProcess = spawn("node", ["dist/ssr-server.js"], {
+    cwd: process.cwd(),
+    env: { ...process.env, NODE_ENV: "production", PORT: "4001" },
+    stdio: "pipe"
+  });
+  const ssrUrl = "http://localhost:4001/render";
+  const serverReady = await waitForServer("http://localhost:4001/health", 15e3);
+  if (!serverReady) {
+    log.warn("SSR server health check failed, attempting rendering anyway...");
+  }
+  log.blank();
+  log.info("Step 3/4: Pre-rendering pages...");
+  const routes = discoverRoutes();
+  const outputDir = path2.resolve(outDir);
+  fs2.mkdirSync(outputDir, { recursive: true });
+  let success = 0;
+  let failed = 0;
+  for (const route of routes) {
+    try {
+      const html = await renderPage(route, ssrUrl);
+      const filePath = route === "/" ? path2.join(outputDir, "index.html") : path2.join(outputDir, route.slice(1), "index.html");
+      fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+      fs2.writeFileSync(filePath, html, "utf-8");
+      console.log(`  ${c.green}\u2713${c.reset} ${route} \u2192 ${path2.relative(process.cwd(), filePath)}`);
+      success++;
+    } catch (err) {
+      console.log(`  ${c.red}\u2717${c.reset} ${route}: ${err.message}`);
+      failed++;
+    }
+  }
+  ssrProcess.kill("SIGTERM");
+  log.blank();
+  log.info("Step 4/4: Copying static assets...");
+  const staticDir = path2.resolve("static");
+  if (fs2.existsSync(staticDir)) {
+    copyDir(staticDir, path2.join(outputDir, "static"));
+    log.success("Static assets copied.");
+  }
+  const distJs = path2.resolve("dist/client");
+  if (fs2.existsSync(distJs)) {
+    copyDir(distJs, path2.join(outputDir, "static/js"));
+  }
+  log.blank();
+  divider();
+  log.blank();
+  log.success(`Static export complete! \u2728`);
+  log.info(`${success} page(s) exported${failed > 0 ? `, ${failed} failed` : ""}`);
+  log.info(`Output: ${c.bold}${outDir}/${c.reset}`);
+  log.blank();
+  log.info(`Deploy anywhere:`);
+  log.info(`  ${c.dim}GitHub Pages:${c.reset} push ${outDir}/ to gh-pages branch`);
+  log.info(`  ${c.dim}Netlify:${c.reset}      set publish directory to ${outDir}/`);
+  log.info(`  ${c.dim}S3:${c.reset}           aws s3 sync ${outDir}/ s3://my-bucket`);
+  log.info(`  ${c.dim}Local:${c.reset}        npx serve ${outDir}/`);
+  log.blank();
+}
+function copyDir(src, dest) {
+  fs2.mkdirSync(dest, { recursive: true });
+  const entries = fs2.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path2.join(src, entry.name);
+    const destPath = path2.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs2.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+export {
+  exportSite
+};