blumenjs 0.1.4 → 0.1.6

package/dist/cli/commands/create.js

@@ -1,12 +1,14 @@
 // cli/commands/create.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 
 // cli/utils.ts
 import * as fs from "fs";
 import * as path from "path";
+import * as os from "os";
 import { fileURLToPath } from "url";
+import { execSync } from "child_process";
 var c = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -85,6 +87,118 @@ async function select(question, options) {
     });
   });
 }
+async function confirm(question, defaultYes = true) {
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const hint = defaultYes ? "Y/n" : "y/N";
+  return new Promise((resolve2) => {
+    rl.question(`  ${c.bold}${question}${c.reset} ${c.dim}(${hint})${c.reset} `, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      if (a === "")
+        resolve2(defaultYes);
+      else
+        resolve2(a === "y" || a === "yes");
+    });
+  });
+}
+function checkGoInstalled() {
+  try {
+    execSync("go version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getGoVersion() {
+  try {
+    const out = execSync("go version", { encoding: "utf-8" }).trim();
+    const match = out.match(/go(\d+\.\d+(\.\d+)?)/);
+    return match ? match[1] : out;
+  } catch {
+    return null;
+  }
+}
+async function ensureGo() {
+  if (checkGoInstalled()) {
+    const ver = getGoVersion();
+    log.success(`Go ${c.bold}${ver}${c.reset} detected`);
+    return true;
+  }
+  log.blank();
+  log.warn(`${c.bold}Go is not installed${c.reset}`);
+  log.info("Blumen uses Go for its high-performance HTTP server layer.");
+  log.blank();
+  const platform2 = os.platform();
+  if (platform2 === "darwin") {
+    let hasBrew = false;
+    try {
+      execSync("brew --version", { stdio: "pipe" });
+      hasBrew = true;
+    } catch {
+    }
+    if (hasBrew) {
+      const doInstall = await confirm("Install Go via Homebrew? (brew install go)");
+      if (doInstall) {
+        log.step("Installing Go via Homebrew...");
+        try {
+          execSync("brew install go", { stdio: "inherit" });
+          log.success("Go installed successfully!");
+          return true;
+        } catch {
+          log.error("Homebrew install failed. Please install manually.");
+          console.log(`
+  ${c.cyan}https://go.dev/dl/${c.reset}
+`);
+          return false;
+        }
+      }
+    }
+    console.log(`  ${c.bold}Install Go manually:${c.reset}`);
+    console.log(`    ${c.cyan}brew install go${c.reset}  ${c.dim}(if you install Homebrew first)${c.reset}`);
+    console.log(`    ${c.dim}or download from${c.reset} ${c.cyan}https://go.dev/dl/${c.reset}`);
+  } else if (platform2 === "linux") {
+    let hasApt = false;
+    try {
+      execSync("apt --version", { stdio: "pipe" });
+      hasApt = true;
+    } catch {
+    }
+    if (hasApt) {
+      const doInstall = await confirm("Install Go via apt? (sudo apt install golang-go)");
+      if (doInstall) {
+        log.step("Installing Go via apt...");
+        try {
+          execSync("sudo apt update && sudo apt install -y golang-go", { stdio: "inherit" });
+          log.success("Go installed successfully!");
+          return true;
+        } catch {
+          log.error("apt install failed. Please install manually.");
+          console.log(`
+  ${c.cyan}https://go.dev/dl/${c.reset}
+`);
+          return false;
+        }
+      }
+    }
+    console.log(`  ${c.bold}Install Go:${c.reset}`);
+    console.log(`    ${c.cyan}sudo apt install golang-go${c.reset}  ${c.dim}(Debian/Ubuntu)${c.reset}`);
+    console.log(`    ${c.cyan}sudo dnf install golang${c.reset}      ${c.dim}(Fedora)${c.reset}`);
+    console.log(`    ${c.dim}or download from${c.reset} ${c.cyan}https://go.dev/dl/${c.reset}`);
+  } else if (platform2 === "win32") {
+    console.log(`  ${c.bold}Install Go (Windows):${c.reset}`);
+    console.log(`    ${c.cyan}winget install GoLang.Go${c.reset}`);
+    console.log(`    ${c.dim}or download from${c.reset} ${c.cyan}https://go.dev/dl/${c.reset}`);
+  } else {
+    console.log(`  ${c.bold}Install Go:${c.reset} ${c.cyan}https://go.dev/dl/${c.reset}`);
+  }
+  log.blank();
+  log.info("After installing Go, restart your terminal and try again.");
+  return false;
+}
 
 // cli/commands/create.ts
 function getFrameworkRoot() {
@@ -369,7 +483,30 @@ function writeFile(base, relPath, content) {
   fs2.mkdirSync(path2.dirname(fullPath), { recursive: true });
   fs2.writeFileSync(fullPath, content, "utf-8");
 }
-function getTemplateFiles(projectName) {
+var TEMPLATE_MAP = {
+  starter: {
+    file: "app/pages/BlumenStarter.tsx",
+    label: "Starter",
+    desc: "Premium landing page with feature cards"
+  },
+  empty: {
+    file: "app/pages/templates/BlumenEmpty.tsx",
+    label: "Empty",
+    desc: "Minimal blank project \u2014 just a centered greeting"
+  },
+  dashboard: {
+    file: "app/pages/templates/BlumenDashboard.tsx",
+    label: "Dashboard",
+    desc: "Admin dashboard with sidebar, stats, and activity feed"
+  },
+  api: {
+    file: "app/pages/templates/BlumenApi.tsx",
+    label: "API",
+    desc: "API explorer with endpoint list and response preview"
+  }
+};
+function getTemplateFiles(projectName, template) {
+  const tpl = TEMPLATE_MAP[template] || TEMPLATE_MAP.starter;
   return [
     // Generated config
     ["package.json", pkgJson(projectName)],
@@ -380,8 +517,9 @@ function getTemplateFiles(projectName) {
     ["app/shared/DefaultApp.tsx", DEFAULT_APP],
     ["app/shared/DefaultDocument.tsx", DEFAULT_DOCUMENT],
     ["app/shared/Link.tsx", LINK_TSX],
-    // Complex files — copied from the framework source (avoids escaping hell)
-    ["app/pages/Home.tsx", readProjectFile("app/pages/BlumenStarter.tsx")],
+    // Home page — determined by template choice
+    ["app/pages/Home.tsx", readProjectFile(tpl.file)],
+    // Complex files — copied from the framework source
     ["app/shared/RouterContext.tsx", readProjectFile("app/shared/RouterContext.tsx")],
     ["app/shared/router.ts", readProjectFile("app/shared/router.ts")],
     ["app/client/entry.tsx", readProjectFile("app/client/entry.tsx")],
@@ -399,11 +537,15 @@ function getTemplateFiles(projectName) {
 async function create(projectName) {
   banner();
   log.info("Create a new Blumen project\n");
+  const goReady = await ensureGo();
+  if (!goReady) {
+    process.exit(1);
+  }
   if (!projectName) {
     log.error("Please provide a project name.");
     console.log(
       `
-  ${c.dim}Usage:${c.reset} blumen create ${c.cyan}<project-name>${c.reset}
+  ${c.dim}Usage:${c.reset} blumen create ${c.cyan}<project-name>${c.reset} ${c.dim}[--template starter|empty|dashboard|api]${c.reset}
 `
     );
     process.exit(1);
@@ -413,6 +555,25 @@ async function create(projectName) {
     log.error(`Directory ${c.bold}${projectName}${c.reset} already exists.`);
     process.exit(1);
   }
+  let template = "";
+  const templateFlagIdx = process.argv.indexOf("--template");
+  if (templateFlagIdx !== -1 && process.argv[templateFlagIdx + 1]) {
+    template = process.argv[templateFlagIdx + 1];
+    if (!TEMPLATE_MAP[template]) {
+      log.error(`Unknown template: ${c.bold}${template}${c.reset}`);
+      log.info(`Available: ${Object.keys(TEMPLATE_MAP).join(", ")}`);
+      process.exit(1);
+    }
+  }
+  if (!template) {
+    template = await select(
+      "Which template do you want to use?",
+      Object.entries(TEMPLATE_MAP).map(
+        ([key, val]) => `${key} \u2014 ${val.desc}`
+      )
+    );
+    template = template.split(" \u2014 ")[0];
+  }
   const pkgManager = await select("Which package manager do you want to use?", [
     "npm",
     "yarn",
@@ -422,8 +583,8 @@ async function create(projectName) {
   log.blank();
   divider();
   log.blank();
-  log.step(`Creating project in ${c.cyan}${projectName}${c.reset}...`);
-  const files = getTemplateFiles(projectName);
+  log.step(`Creating project in ${c.cyan}${projectName}${c.reset} with ${c.magenta}${template}${c.reset} template...`);
+  const files = getTemplateFiles(projectName, template);
   for (const [relPath, content] of files) {
     writeFile(projectDir, relPath, content);
   }
@@ -436,7 +597,7 @@ async function create(projectName) {
     bun: "bun install"
   };
   try {
-    execSync(installCmd[pkgManager], {
+    execSync2(installCmd[pkgManager], {
       cwd: projectDir,
       stdio: "inherit"
     });
@@ -449,7 +610,7 @@ async function create(projectName) {
   log.blank();
   divider();
   log.blank();
-  log.success(`${c.bold}Project created!${c.reset}`);
+  log.success(`${c.bold}Project created!${c.reset} (template: ${c.magenta}${template}${c.reset})`);
   log.blank();
   console.log(`  ${c.dim}Next steps:${c.reset}`);
   console.log(`    cd ${projectName}`);

package/dist/cli/commands/deploy.js

@@ -0,0 +1,346 @@
+// cli/commands/deploy.ts
+import { execSync, spawnSync } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// 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}`);
+}
+async function confirm(question, defaultYes = true) {
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const hint = defaultYes ? "Y/n" : "y/N";
+  return new Promise((resolve) => {
+    rl.question(`  ${c.bold}${question}${c.reset} ${c.dim}(${hint})${c.reset} `, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      if (a === "")
+        resolve(defaultYes);
+      else
+        resolve(a === "y" || a === "yes");
+    });
+  });
+}
+
+// cli/commands/deploy.ts
+var PLATFORMS = [
+  { name: "Docker (any cloud)", ok: true, note: "Best option \u2014 multi-stage Dockerfile included" },
+  { name: "Railway", ok: true, note: "Auto-detects Dockerfile, deploy with railway up" },
+  { name: "Fly.io", ok: true, note: "Docker-based deploys via fly deploy" },
+  { name: "Render", ok: true, note: "Docker support, auto-deploy from Git" },
+  { name: "AWS EC2 / GCP / Azure", ok: true, note: "Full control, any runtime" },
+  { name: "DigitalOcean", ok: true, note: "App Platform supports Docker" },
+  { name: "Vercel", ok: false, note: "Node-only, no Go runtime" },
+  { name: "Netlify", ok: false, note: "Static/serverless only, no Go" }
+];
+function hasCommand(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureDockerfile() {
+  if (!fs2.existsSync("Dockerfile")) {
+    log.error("No Dockerfile found in the current directory.");
+    log.info(
+      `Run ${c.bold}blumen create${c.reset} to scaffold a project with Docker support.`
+    );
+    process.exit(1);
+  }
+}
+async function deployDocker() {
+  log.info("Docker Deployment\n");
+  ensureDockerfile();
+  if (!hasCommand("docker")) {
+    log.error("Docker is not installed.");
+    log.info(
+      `Install Docker: ${c.cyan}https://docs.docker.com/get-docker/${c.reset}`
+    );
+    process.exit(1);
+  }
+  const projectName = path2.basename(process.cwd()).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const imageName = `blumen-${projectName}`;
+  log.step(`Building image: ${c.bold}${imageName}${c.reset}...`);
+  divider();
+  log.blank();
+  const buildResult = spawnSync("docker", ["build", "-t", imageName, "."], {
+    cwd: process.cwd(),
+    stdio: "inherit"
+  });
+  log.blank();
+  divider();
+  if (buildResult.status !== 0) {
+    log.error("Docker build failed.");
+    process.exit(1);
+  }
+  log.success(`Image ${c.bold}${imageName}${c.reset} built successfully!`);
+  log.blank();
+  const shouldRun = await confirm("Run the container now?");
+  if (shouldRun) {
+    log.step(`Starting ${c.bold}${imageName}${c.reset} on port 3000...`);
+    log.blank();
+    console.log(
+      `  ${c.dim}\u279C${c.reset}  ${c.bold}App${c.reset}:  ${c.cyan}http://localhost:3000${c.reset}`
+    );
+    console.log(
+      `  ${c.dim}Press ${c.bold}Ctrl+C${c.reset}${c.dim} to stop.${c.reset}`
+    );
+    log.blank();
+    spawnSync("docker", ["run", "--rm", "-p", "3000:3000", imageName], {
+      cwd: process.cwd(),
+      stdio: "inherit"
+    });
+  } else {
+    log.blank();
+    console.log(`  ${c.dim}Run manually:${c.reset}`);
+    console.log(`    docker run -p 3000:3000 ${imageName}`);
+    log.blank();
+  }
+}
+async function deployFly() {
+  log.info("Fly.io Deployment\n");
+  ensureDockerfile();
+  const projectName = path2.basename(process.cwd()).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  if (!fs2.existsSync("fly.toml")) {
+    log.step("Generating fly.toml...");
+    const flyConfig = `# Fly.io configuration for Blumen app
+# Deploy with: fly deploy
+
+app = "${projectName}"
+primary_region = "iad"
+
+[build]
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = "stop"
+  auto_start_machines = true
+  min_machines_running = 0
+
+[checks]
+  [checks.health]
+    type = "http"
+    port = 3000
+    path = "/"
+    interval = "30s"
+    timeout = "5s"
+
+[[vm]]
+  memory = "512mb"
+  cpu_kind = "shared"
+  cpus = 1
+`;
+    fs2.writeFileSync("fly.toml", flyConfig);
+    log.success("fly.toml created");
+  } else {
+    log.info("fly.toml already exists, skipping generation.");
+  }
+  log.blank();
+  if (!hasCommand("fly") && !hasCommand("flyctl")) {
+    log.warn("Fly CLI is not installed.");
+    log.blank();
+    console.log(`  ${c.dim}Install:${c.reset}`);
+    console.log(`    curl -L https://fly.io/install.sh | sh`);
+    log.blank();
+    console.log(`  ${c.dim}Then deploy:${c.reset}`);
+    console.log(`    fly launch`);
+    console.log(`    fly deploy`);
+    log.blank();
+    return;
+  }
+  const shouldDeploy = await confirm("Deploy to Fly.io now?");
+  if (shouldDeploy) {
+    log.step("Deploying to Fly.io...");
+    divider();
+    log.blank();
+    const flyCmd = hasCommand("fly") ? "fly" : "flyctl";
+    spawnSync(flyCmd, ["deploy"], {
+      cwd: process.cwd(),
+      stdio: "inherit"
+    });
+    log.blank();
+    divider();
+    log.success("Deployment complete!");
+  } else {
+    log.blank();
+    console.log(`  ${c.dim}Deploy later:${c.reset}`);
+    console.log(`    fly deploy`);
+    log.blank();
+  }
+}
+async function deployRailway() {
+  log.info("Railway Deployment\n");
+  ensureDockerfile();
+  if (!fs2.existsSync("railway.toml")) {
+    log.step("Generating railway.toml...");
+    const railwayConfig = `# Railway configuration for Blumen app
+# Deploy with: railway up
+
+[build]
+  builder = "DOCKERFILE"
+  dockerfilePath = "Dockerfile"
+
+[deploy]
+  startCommand = ""
+  healthcheckPath = "/"
+  healthcheckTimeout = 30
+  restartPolicyType = "ON_FAILURE"
+  restartPolicyMaxRetries = 5
+`;
+    fs2.writeFileSync("railway.toml", railwayConfig);
+    log.success("railway.toml created");
+  } else {
+    log.info("railway.toml already exists, skipping generation.");
+  }
+  log.blank();
+  if (!hasCommand("railway")) {
+    log.warn("Railway CLI is not installed.");
+    log.blank();
+    console.log(`  ${c.dim}Install:${c.reset}`);
+    console.log(`    npm install -g @railway/cli`);
+    log.blank();
+    console.log(`  ${c.dim}Then deploy:${c.reset}`);
+    console.log(`    railway login`);
+    console.log(`    railway up`);
+    log.blank();
+    return;
+  }
+  const shouldDeploy = await confirm("Deploy to Railway now?");
+  if (shouldDeploy) {
+    log.step("Deploying to Railway...");
+    divider();
+    log.blank();
+    spawnSync("railway", ["up"], {
+      cwd: process.cwd(),
+      stdio: "inherit"
+    });
+    log.blank();
+    divider();
+    log.success("Deployment complete!");
+  } else {
+    log.blank();
+    console.log(`  ${c.dim}Deploy later:${c.reset}`);
+    console.log(`    railway up`);
+    log.blank();
+  }
+}
+function showInfo() {
+  log.info("Hosting Compatibility\n");
+  console.log(`  Blumen apps require ${c.bold}Go${c.reset} + ${c.bold}Node.js${c.reset} \u2014 use Docker-compatible platforms.
+`);
+  const maxName = Math.max(...PLATFORMS.map((p) => p.name.length));
+  for (const p of PLATFORMS) {
+    const icon = p.ok ? `${c.green}\u2713${c.reset}` : `${c.red}\u2717${c.reset}`;
+    const name = p.name.padEnd(maxName + 2);
+    const note = `${c.dim}${p.note}${c.reset}`;
+    console.log(`  ${icon}  ${name} ${note}`);
+  }
+  log.blank();
+  divider();
+  log.blank();
+  console.log(`  ${c.bold}Quick start:${c.reset}`);
+  log.blank();
+  console.log(`  ${c.dim}Docker (local):${c.reset}      docker compose up`);
+  console.log(`  ${c.dim}Fly.io:${c.reset}              blumen deploy fly`);
+  console.log(`  ${c.dim}Railway:${c.reset}             blumen deploy railway`);
+  log.blank();
+}
+async function deploy(subcommand) {
+  banner();
+  if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+    log.info("Deploy your Blumen app\n");
+    console.log(`  ${c.bold}Usage${c.reset}   blumen deploy ${c.dim}<target>${c.reset}
+`);
+    console.log(`  ${c.bold}Targets${c.reset}`);
+    console.log(`    docker     Build Docker image and optionally run`);
+    console.log(`    fly        Generate config and deploy to Fly.io`);
+    console.log(`    railway    Generate config and deploy to Railway`);
+    console.log(`    info       Show hosting compatibility matrix`);
+    console.log("");
+    return;
+  }
+  switch (subcommand) {
+    case "docker":
+      await deployDocker();
+      break;
+    case "fly":
+      await deployFly();
+      break;
+    case "railway":
+      await deployRailway();
+      break;
+    case "info":
+      showInfo();
+      break;
+    default:
+      log.error(`Unknown deploy target: ${c.bold}${subcommand}${c.reset}`);
+      log.info(
+        `Run ${c.bold}blumen deploy --help${c.reset} for available targets.`
+      );
+      process.exit(1);
+  }
+}
+export {
+  deploy
+};