blumenjs 0.1.4 → 0.1.6

package/cli/postinstall.cjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * Blumen — postinstall check
+ *
+ * Runs after `npm install -g blumenjs` to verify Go is available.
+ * If not, prints install instructions for the user's platform.
+ */
+
+const { execSync } = require("child_process");
+const os = require("os");
+
+const c = {
+	reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+	red: "\x1b[31m", green: "\x1b[32m", yellow: "\x1b[33m",
+	cyan: "\x1b[36m", magenta: "\x1b[35m",
+};
+
+function hasGo() {
+	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;
+	}
+}
+
+console.log("");
+console.log(`  ${c.magenta}${c.bold}🌸 Blumen${c.reset} ${c.dim}installed successfully!${c.reset}`);
+console.log(`  ${c.dim}The React framework powered by Go${c.reset}`);
+console.log("");
+
+if (hasGo()) {
+	const ver = getGoVersion();
+	console.log(`  ${c.green}✓${c.reset}  Go ${c.bold}${ver}${c.reset} detected`);
+	console.log(`  ${c.green}✓${c.reset}  Ready to go! Run ${c.cyan}blumen create my-app${c.reset} to start.`);
+} else {
+	console.log(`  ${c.yellow}⚠${c.reset}  ${c.bold}Go is not installed${c.reset}`);
+	console.log(`  ${c.dim}Blumen uses Go for its high-performance server layer.${c.reset}`);
+	console.log("");
+
+	const platform = os.platform();
+
+	if (platform === "darwin") {
+		console.log(`  ${c.bold}Install Go (macOS):${c.reset}`);
+		console.log(`    ${c.cyan}brew install go${c.reset}`);
+		console.log(`    ${c.dim}or download from https://go.dev/dl/${c.reset}`);
+	} else if (platform === "linux") {
+		console.log(`  ${c.bold}Install Go (Linux):${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 https://go.dev/dl/${c.reset}`);
+	} else if (platform === "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 https://go.dev/dl/${c.reset}`);
+	} else {
+		console.log(`  ${c.bold}Install Go:${c.reset} ${c.cyan}https://go.dev/dl/${c.reset}`);
+	}
+
+	console.log("");
+	console.log(`  ${c.dim}After installing Go, run:${c.reset} ${c.cyan}blumen create my-app${c.reset}`);
+}
+
+console.log("");

package/dist/cli/blumen.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 // cli/commands/dev.ts
-import { spawn, execSync } from "child_process";
+import { spawn, 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",
@@ -84,13 +86,129 @@ 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/dev.ts
 async function dev() {
   banner();
+  const goReady = await ensureGo();
+  if (!goReady) {
+    process.exit(1);
+  }
   log.step("Generating routes...");
   try {
-    execSync("npx tsx scripts/generate-routes.ts", {
+    execSync2("npx tsx scripts/generate-routes.ts", {
       stdio: "pipe",
       cwd: process.cwd()
     });
@@ -202,7 +320,7 @@ async function dev() {
 }
 
 // cli/commands/build.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 async function build() {
   banner();
   log.info("Creating production build...");
@@ -226,7 +344,7 @@ async function build() {
     const step = steps[i];
     log.step(`[${i + 1}/${steps.length}] ${step.label}...`);
     try {
-      execSync2(step.cmd, { stdio: "inherit", cwd: process.cwd() });
+      execSync3(step.cmd, { stdio: "inherit", cwd: process.cwd() });
       log.success(step.label);
     } catch {
       log.error(`Failed: ${step.label}`);
@@ -338,7 +456,7 @@ async function start() {
 // cli/commands/create.ts
 import * as fs3 from "fs";
 import * as path2 from "path";
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 function getFrameworkRoot() {
   const cliEntry = fs3.realpathSync(process.argv[1]);
   const cliDir = path2.dirname(cliEntry);
@@ -621,7 +739,30 @@ function writeFile(base, relPath, content) {
   fs3.mkdirSync(path2.dirname(fullPath), { recursive: true });
   fs3.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)],
@@ -632,8 +773,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")],
@@ -651,11 +793,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);
@@ -665,6 +811,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",
@@ -674,8 +839,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);
   }
@@ -688,7 +853,7 @@ async function create(projectName) {
     bun: "bun install"
   };
   try {
-    execSync3(installCmd[pkgManager], {
+    execSync4(installCmd[pkgManager], {
       cwd: projectDir,
       stdio: "inherit"
     });
@@ -701,7 +866,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}`);
@@ -709,6 +874,271 @@ async function create(projectName) {
   log.blank();
 }
 
+// cli/commands/deploy.ts
+import { execSync as execSync5, spawnSync } from "child_process";
+import * as fs4 from "fs";
+import * as path3 from "path";
+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 {
+    execSync5(`which ${cmd}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureDockerfile() {
+  if (!fs4.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 = path3.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 = path3.basename(process.cwd()).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  if (!fs4.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
+`;
+    fs4.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 (!fs4.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
+`;
+    fs4.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);
+  }
+}
+
 // cli/blumen.ts
 async function main() {
   const command = process.argv[2];
@@ -727,6 +1157,9 @@ async function main() {
     console.log(
       `    create     Scaffold a new Blumen project`
     );
+    console.log(
+      `    deploy     Deploy to Docker, Fly.io, or Railway`
+    );
     console.log("");
     console.log(`  ${c.bold}Options${c.reset}`);
     console.log(`    --help     Show this help message`);
@@ -751,6 +1184,9 @@ async function main() {
     case "create":
       await create(process.argv[3]);
       break;
+    case "deploy":
+      await deploy(process.argv[3]);
+      break;
     default:
       log.error(
         `Unknown command: ${c.bold}${command}${c.reset}`