blumenjs 0.1.4 → 0.1.5

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
+};