@weirdfingers/baseboards 0.2.0

package/dist/index.js

@@ -0,0 +1,887 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname, join } from "path";
+import chalk9 from "chalk";
+
+// src/commands/up.ts
+import { execa as execa2 } from "execa";
+import fs2 from "fs-extra";
+import path2 from "path";
+import chalk2 from "chalk";
+import ora from "ora";
+import prompts from "prompts";
+
+// src/utils.ts
+import { execa } from "execa";
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import which from "which";
+import chalk from "chalk";
+import crypto from "crypto";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function getTemplatesDir() {
+  return path.join(__dirname, "../templates");
+}
+async function checkPrerequisites() {
+  const prereqs = {
+    docker: { installed: false },
+    node: { installed: true, satisfies: false },
+    platform: { name: process.platform }
+  };
+  try {
+    const dockerPath = await which("docker");
+    prereqs.docker.installed = !!dockerPath;
+    if (dockerPath) {
+      const { stdout } = await execa("docker", ["--version"]);
+      const match = stdout.match(/Docker version ([\d.]+)/);
+      if (match) {
+        prereqs.docker.version = match[1];
+      }
+      try {
+        const { stdout: composeStdout } = await execa("docker", [
+          "compose",
+          "version"
+        ]);
+        const composeMatch = composeStdout.match(/version v?([\d.]+)/);
+        if (composeMatch) {
+          prereqs.docker.composeVersion = composeMatch[1];
+        }
+      } catch (e) {
+      }
+    }
+  } catch (e) {
+  }
+  const nodeVersion = process.version.replace("v", "");
+  prereqs.node.version = nodeVersion;
+  const majorVersion = parseInt(nodeVersion.split(".")[0], 10);
+  prereqs.node.satisfies = majorVersion >= 20;
+  if (process.platform === "linux") {
+    try {
+      const { stdout } = await execa("uname", ["-r"]);
+      if (stdout.toLowerCase().includes("microsoft") || stdout.toLowerCase().includes("wsl")) {
+        prereqs.platform.isWSL = true;
+      }
+    } catch (e) {
+    }
+  }
+  return prereqs;
+}
+async function assertPrerequisites() {
+  const prereqs = await checkPrerequisites();
+  const errors = [];
+  if (!prereqs.docker.installed) {
+    errors.push(
+      "\u{1F433} Docker is not installed.",
+      "   Install from: https://docs.docker.com/get-docker/"
+    );
+  } else if (!prereqs.docker.composeVersion) {
+    errors.push(
+      "\u{1F433} Docker Compose (v2) is not available.",
+      "   Update Docker to get Compose v2: https://docs.docker.com/compose/install/"
+    );
+  }
+  if (!prereqs.node.satisfies) {
+    errors.push(
+      `\u26A0\uFE0F  Node.js ${prereqs.node.version} is too old (need v20+).`,
+      "   Install from: https://nodejs.org/"
+    );
+  }
+  if (errors.length > 0) {
+    console.error(chalk.red("\n\u274C Prerequisites not met:\n"));
+    errors.forEach((err) => console.error(chalk.yellow(err)));
+    console.error("");
+    process.exit(1);
+  }
+}
+function isScaffolded(dir) {
+  const keyFiles = [
+    "compose.yaml",
+    "web/package.json",
+    "api/pyproject.toml"
+  ];
+  return keyFiles.every((file) => fs.existsSync(path.join(dir, file)));
+}
+async function findAvailablePort(preferred, maxAttempts = 50) {
+  for (let port = preferred; port < preferred + maxAttempts; port++) {
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new Error(`No available port found near ${preferred}`);
+}
+async function isPortAvailable(port) {
+  const { createServer } = await import("net");
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port);
+  });
+}
+function generateSecret(length = 32) {
+  return crypto.randomBytes(length).toString("hex");
+}
+function generatePassword(length = 24) {
+  const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*";
+  let password = "";
+  const bytes = crypto.randomBytes(length);
+  for (let i = 0; i < length; i++) {
+    password += charset[bytes[i] % charset.length];
+  }
+  return password;
+}
+function parsePortsOption(portsStr) {
+  const ports = {};
+  const pairs = portsStr.split(/\s+/);
+  for (const pair of pairs) {
+    const [service, port] = pair.split("=");
+    const portNum = parseInt(port, 10);
+    if (service && ["web", "api", "db", "redis"].includes(service) && !isNaN(portNum)) {
+      ports[service] = portNum;
+    }
+  }
+  return ports;
+}
+function getCliVersion() {
+  const packagePath = path.join(__dirname, "../package.json");
+  const packageJson2 = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+  return packageJson2.version;
+}
+function detectMissingProviderKeys(envPath) {
+  if (!fs.existsSync(envPath)) {
+    return [];
+  }
+  const envContent = fs.readFileSync(envPath, "utf-8");
+  const providerKeys = [
+    "REPLICATE_API_KEY",
+    "FAL_KEY",
+    "OPENAI_API_KEY",
+    "GOOGLE_API_KEY"
+  ];
+  const missingKeys = [];
+  for (const key of providerKeys) {
+    const regex = new RegExp(`^${key}=(.*)$`, "m");
+    const match = envContent.match(regex);
+    if (!match || !match[1] || match[1].trim() === "") {
+      missingKeys.push(key);
+    }
+  }
+  if (missingKeys.length === providerKeys.length) {
+    return missingKeys;
+  }
+  return [];
+}
+async function waitFor(condition, options) {
+  const { timeoutMs, intervalMs = 1e3, onProgress } = options;
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    if (await condition()) {
+      return true;
+    }
+    if (onProgress) {
+      onProgress(Date.now() - startTime);
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  return false;
+}
+
+// src/commands/up.ts
+async function up(directory, options) {
+  console.log(chalk2.blue.bold("\n\u{1F3A8} Baseboards CLI\n"));
+  const spinner = ora("Checking prerequisites...").start();
+  await assertPrerequisites();
+  spinner.succeed("Prerequisites OK");
+  const dir = path2.resolve(process.cwd(), directory);
+  const name = path2.basename(dir);
+  const version = getCliVersion();
+  const mode = options.prod ? "prod" : "dev";
+  let customPorts = {};
+  if (options.ports) {
+    customPorts = parsePortsOption(options.ports);
+  }
+  const defaultPorts = {
+    web: 3300,
+    api: 8800,
+    db: 5432,
+    redis: 6379,
+    ...customPorts
+  };
+  const ctx = {
+    dir,
+    name,
+    isScaffolded: isScaffolded(dir),
+    ports: defaultPorts,
+    mode,
+    version
+  };
+  const isFreshScaffold = !ctx.isScaffolded;
+  if (!ctx.isScaffolded) {
+    console.log(
+      chalk2.cyan(`
+\u{1F4E6} Scaffolding new project: ${chalk2.bold(name)}`)
+    );
+    await scaffoldProject(ctx);
+  } else {
+    console.log(
+      chalk2.green(`
+\u2705 Project already scaffolded: ${chalk2.bold(name)}`)
+    );
+  }
+  spinner.start("Checking port availability...");
+  ctx.ports.web = await findAvailablePort(ctx.ports.web);
+  ctx.ports.api = await findAvailablePort(ctx.ports.api);
+  spinner.succeed(
+    `Ports available: web=${ctx.ports.web}, api=${ctx.ports.api}`
+  );
+  await ensureEnvFiles(ctx);
+  if (isFreshScaffold) {
+    await promptForApiKeys(ctx);
+  }
+  const apiEnvPath = path2.join(ctx.dir, "api/.env");
+  const missingKeys = detectMissingProviderKeys(apiEnvPath);
+  if (missingKeys.length > 0) {
+    console.log(chalk2.yellow("\n\u26A0\uFE0F  Provider API keys not configured!"));
+    console.log(chalk2.gray("   Add at least one API key to api/.env:"));
+    console.log(
+      chalk2.cyan("   \u2022 REPLICATE_API_KEY") + chalk2.gray(" - https://replicate.com/account/api-tokens")
+    );
+    console.log(
+      chalk2.cyan("   \u2022 FAL_KEY") + chalk2.gray(" - https://fal.ai/dashboard/keys")
+    );
+    console.log(
+      chalk2.cyan("   \u2022 OPENAI_API_KEY") + chalk2.gray(" - https://platform.openai.com/api-keys")
+    );
+    console.log(
+      chalk2.cyan("   \u2022 GOOGLE_API_KEY") + chalk2.gray(" - https://makersuite.google.com/app/apikey")
+    );
+    console.log(
+      chalk2.gray(
+        "\n   The app will start, but image generation won't work without keys.\n"
+      )
+    );
+  }
+  await startDockerCompose(ctx, true);
+  await waitForHealthy(ctx);
+  await runMigrations(ctx);
+  printSuccessMessage(ctx, options.detached || false, missingKeys.length > 0);
+  if (!options.detached) {
+    try {
+      await attachToLogs(ctx);
+    } catch (error) {
+      if (error.signal === "SIGINT" || error.exitCode === 130) {
+        console.log(chalk2.yellow("\n\n\u26A0\uFE0F  Interrupted - services stopped"));
+        process.exit(0);
+      }
+      throw error;
+    }
+  }
+}
+async function scaffoldProject(ctx) {
+  const templatesDir = getTemplatesDir();
+  const spinner = ora("Copying templates...").start();
+  fs2.ensureDirSync(ctx.dir);
+  fs2.copySync(path2.join(templatesDir, "web"), path2.join(ctx.dir, "web"));
+  fs2.copySync(path2.join(templatesDir, "api"), path2.join(ctx.dir, "api"));
+  const rootFiles = [
+    "compose.yaml",
+    "compose.dev.yaml",
+    "README.md",
+    ".gitignore"
+  ];
+  for (const file of rootFiles) {
+    const src = path2.join(templatesDir, file);
+    const dest = path2.join(ctx.dir, file);
+    if (fs2.existsSync(src)) {
+      fs2.copySync(src, dest);
+    }
+  }
+  fs2.copySync(path2.join(templatesDir, "docker"), path2.join(ctx.dir, "docker"));
+  spinner.succeed("Templates copied");
+  spinner.start("Creating data directories...");
+  fs2.ensureDirSync(path2.join(ctx.dir, "data/storage"));
+  spinner.succeed("Data directories created");
+  console.log(chalk2.green("   \u2728 Project scaffolded successfully!"));
+}
+async function ensureEnvFiles(ctx) {
+  const spinner = ora("Configuring environment...").start();
+  const webEnvPath = path2.join(ctx.dir, "web/.env");
+  const webEnvExamplePath = path2.join(ctx.dir, "web/.env.example");
+  if (!fs2.existsSync(webEnvPath) && fs2.existsSync(webEnvExamplePath)) {
+    let webEnv = fs2.readFileSync(webEnvExamplePath, "utf-8");
+    webEnv = webEnv.replace(
+      "http://localhost:8800",
+      `http://localhost:${ctx.ports.api}`
+    );
+    fs2.writeFileSync(webEnvPath, webEnv);
+  }
+  const apiEnvPath = path2.join(ctx.dir, "api/.env");
+  const apiEnvExamplePath = path2.join(ctx.dir, "api/.env.example");
+  if (!fs2.existsSync(apiEnvPath) && fs2.existsSync(apiEnvExamplePath)) {
+    let apiEnv = fs2.readFileSync(apiEnvExamplePath, "utf-8");
+    if (apiEnv.includes("BOARDS_JWT_SECRET=\n") || apiEnv.includes("BOARDS_JWT_SECRET=\r\n")) {
+      const jwtSecret = generateSecret(32);
+      apiEnv = apiEnv.replace(
+        /BOARDS_JWT_SECRET=.*$/m,
+        `BOARDS_JWT_SECRET=${jwtSecret}`
+      );
+    }
+    fs2.writeFileSync(apiEnvPath, apiEnv);
+  }
+  const dockerEnvPath = path2.join(ctx.dir, "docker/.env");
+  const dockerEnvExamplePath = path2.join(ctx.dir, "docker/env.example");
+  if (!fs2.existsSync(dockerEnvPath) && fs2.existsSync(dockerEnvExamplePath)) {
+    let dockerEnv = fs2.readFileSync(dockerEnvExamplePath, "utf-8");
+    const dbPassword = generatePassword(24);
+    const dbPasswordEncoded = encodeURIComponent(dbPassword);
+    dockerEnv = dockerEnv.replace(
+      /POSTGRES_PASSWORD=.*/g,
+      `POSTGRES_PASSWORD=${dbPassword}`
+    );
+    dockerEnv = dockerEnv.replace(
+      /REPLACE_WITH_GENERATED_PASSWORD/g,
+      dbPasswordEncoded
+    );
+    dockerEnv = dockerEnv.replace(/WEB_PORT=.*/g, `WEB_PORT=${ctx.ports.web}`);
+    dockerEnv = dockerEnv.replace(/API_PORT=.*/g, `API_PORT=${ctx.ports.api}`);
+    dockerEnv = dockerEnv.replace(/VERSION=.*/g, `VERSION=${ctx.version}`);
+    dockerEnv = dockerEnv.replace(
+      /PROJECT_NAME=.*/g,
+      `PROJECT_NAME=${ctx.name}`
+    );
+    fs2.writeFileSync(dockerEnvPath, dockerEnv);
+  }
+  spinner.succeed("Environment configured");
+}
+async function promptForApiKeys(ctx) {
+  console.log(chalk2.cyan("\n\u{1F511} API Key Configuration"));
+  console.log(chalk2.gray("Add API keys to enable image generation providers"));
+  console.log(chalk2.gray("Press Enter to skip any key\n"));
+  const response = await prompts([
+    {
+      type: "text",
+      name: "REPLICATE_API_KEY",
+      message: "Replicate API Key (https://replicate.com/account/api-tokens):",
+      initial: ""
+    },
+    {
+      type: "text",
+      name: "OPENAI_API_KEY",
+      message: "OpenAI API Key (https://platform.openai.com/api-keys):",
+      initial: ""
+    }
+  ]);
+  const apiKeys = {};
+  if (response.REPLICATE_API_KEY && response.REPLICATE_API_KEY.trim()) {
+    apiKeys.REPLICATE_API_KEY = response.REPLICATE_API_KEY.trim();
+  }
+  if (response.OPENAI_API_KEY && response.OPENAI_API_KEY.trim()) {
+    apiKeys.OPENAI_API_KEY = response.OPENAI_API_KEY.trim();
+  }
+  if (Object.keys(apiKeys).length > 0) {
+    const apiEnvPath = path2.join(ctx.dir, "api/.env");
+    let apiEnv = fs2.readFileSync(apiEnvPath, "utf-8");
+    const jsonKeys = JSON.stringify(apiKeys);
+    if (apiEnv.includes("BOARDS_GENERATOR_API_KEYS=")) {
+      apiEnv = apiEnv.replace(
+        /BOARDS_GENERATOR_API_KEYS=.*$/m,
+        `BOARDS_GENERATOR_API_KEYS=${jsonKeys}`
+      );
+    } else {
+      apiEnv = apiEnv.replace(
+        /(BOARDS_JWT_SECRET=.*\n)/,
+        `$1
+# Generator API Keys (JSON format)
+BOARDS_GENERATOR_API_KEYS=${jsonKeys}
+`
+      );
+    }
+    fs2.writeFileSync(apiEnvPath, apiEnv);
+    console.log(chalk2.green("\n\u2705 API keys saved to api/.env"));
+    console.log(
+      chalk2.gray("   You can edit this file anytime to add/update keys\n")
+    );
+  } else {
+    console.log(chalk2.yellow("\n\u26A0\uFE0F  No API keys provided"));
+    console.log(chalk2.gray("   You can add them later by editing api/.env\n"));
+  }
+}
+async function startDockerCompose(ctx, detached) {
+  const spinner = ora("Starting Docker Compose...").start();
+  const composeFiles = ["compose.yaml"];
+  if (ctx.mode === "dev") {
+    composeFiles.push("compose.dev.yaml");
+  }
+  const composeArgs = [
+    "compose",
+    ...composeFiles.flatMap((f) => ["-f", f]),
+    "up",
+    "-d",
+    "--remove-orphans"
+  ];
+  try {
+    await execa2("docker", composeArgs, {
+      cwd: ctx.dir,
+      stdio: "inherit"
+    });
+    spinner.succeed("Docker Compose started");
+  } catch (error) {
+    spinner.fail("Failed to start Docker Compose");
+    throw error;
+  }
+}
+async function attachToLogs(ctx) {
+  console.log(
+    chalk2.gray("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")
+  );
+  console.log(chalk2.gray("Streaming logs... (Press Ctrl+C to stop)\n"));
+  const composeFiles = ["compose.yaml"];
+  if (ctx.mode === "dev") {
+    composeFiles.push("compose.dev.yaml");
+  }
+  const composeArgs = [
+    "compose",
+    ...composeFiles.flatMap((f) => ["-f", f]),
+    "logs",
+    "-f"
+  ];
+  await execa2("docker", composeArgs, {
+    cwd: ctx.dir,
+    stdio: "inherit"
+  });
+}
+async function waitForHealthy(ctx) {
+  const spinner = ora("Waiting for services to be healthy...").start();
+  const services = ["db", "cache", "api", "worker", "web"];
+  const maxWaitMs = 12e4;
+  const checkHealth = async () => {
+    try {
+      const { stdout } = await execa2(
+        "docker",
+        ["compose", "ps", "--format", "json"],
+        {
+          cwd: ctx.dir
+        }
+      );
+      const containers = stdout.split("\n").filter(Boolean).map((line) => JSON.parse(line));
+      const allHealthy = services.every((service) => {
+        const container = containers.find((c) => c.Service === service);
+        return container && (container.Health === "healthy" || container.State === "running");
+      });
+      return allHealthy;
+    } catch (e) {
+      return false;
+    }
+  };
+  const success = await waitFor(checkHealth, {
+    timeoutMs: maxWaitMs,
+    intervalMs: 2e3,
+    onProgress: (elapsed) => {
+      const seconds = Math.floor(elapsed / 1e3);
+      spinner.text = `Waiting for services to be healthy... (${seconds}s)`;
+    }
+  });
+  if (success) {
+    spinner.succeed("All services healthy");
+  } else {
+    spinner.warn("Services taking longer than expected...");
+    console.log(
+      chalk2.yellow(
+        "\n\u26A0\uFE0F  Health check timeout. Services may still be starting."
+      )
+    );
+    console.log(
+      chalk2.gray("   Run"),
+      chalk2.cyan("baseboards logs"),
+      chalk2.gray("to check progress.")
+    );
+  }
+}
+async function runMigrations(ctx) {
+  const spinner = ora("Running database migrations...").start();
+  try {
+    await execa2(
+      "docker",
+      ["compose", "exec", "-T", "api", "alembic", "upgrade", "head"],
+      {
+        cwd: ctx.dir
+      }
+    );
+    spinner.succeed("Database migrations complete");
+  } catch (error) {
+    spinner.fail("Database migrations failed");
+    console.log(
+      chalk2.yellow(
+        "\n\u26A0\uFE0F  Database migrations failed. You may need to run them manually:"
+      )
+    );
+    console.log(error);
+    console.log(chalk2.cyan("   docker compose exec api alembic upgrade head"));
+  }
+}
+function printSuccessMessage(ctx, detached, hasKeyWarning) {
+  console.log(chalk2.green.bold("\n\u2728 Baseboards is running!\n"));
+  console.log(
+    chalk2.cyan("  \u{1F310} Web:"),
+    chalk2.underline(`http://localhost:${ctx.ports.web}`)
+  );
+  console.log(
+    chalk2.cyan("  \u{1F50C} API:"),
+    chalk2.underline(`http://localhost:${ctx.ports.api}`)
+  );
+  console.log(
+    chalk2.cyan("  \u{1F4CA} GraphQL:"),
+    chalk2.underline(`http://localhost:${ctx.ports.api}/graphql`)
+  );
+  if (hasKeyWarning) {
+    console.log(chalk2.yellow("\n\u26A0\uFE0F  Remember to configure provider API keys!"));
+    console.log(chalk2.gray("   Edit:"), chalk2.cyan("api/.env"));
+    console.log(
+      chalk2.gray("   Docs:"),
+      chalk2.cyan("https://baseboards.dev/docs/setup")
+    );
+  }
+  console.log(chalk2.gray("\n\u{1F4D6} Commands:"));
+  console.log(chalk2.gray("   Stop:"), chalk2.cyan("baseboards down"));
+  console.log(chalk2.gray("   Logs:"), chalk2.cyan("baseboards logs"));
+  console.log(chalk2.gray("   Status:"), chalk2.cyan("baseboards status"));
+  console.log();
+}
+
+// src/commands/down.ts
+import { execa as execa3 } from "execa";
+import path3 from "path";
+import chalk3 from "chalk";
+import ora2 from "ora";
+async function down(directory, options) {
+  const dir = path3.resolve(process.cwd(), directory);
+  if (!isScaffolded(dir)) {
+    console.error(chalk3.red("\n\u274C Error: Not a Baseboards project"));
+    console.log(chalk3.gray("   Run"), chalk3.cyan("baseboards up"), chalk3.gray("to scaffold a project first."));
+    process.exit(1);
+  }
+  const spinner = ora2("Stopping services...").start();
+  const args = ["compose", "down"];
+  if (options.volumes) {
+    args.push("--volumes");
+  }
+  try {
+    await execa3("docker", args, {
+      cwd: dir
+    });
+    spinner.succeed("Services stopped");
+    if (options.volumes) {
+      console.log(chalk3.yellow("\u26A0\uFE0F  Volumes removed (database data deleted)"));
+    }
+  } catch (error) {
+    spinner.fail("Failed to stop services");
+    throw error;
+  }
+}
+
+// src/commands/logs.ts
+import { execa as execa4 } from "execa";
+import path4 from "path";
+import chalk4 from "chalk";
+async function logs(directory, services, options) {
+  const dir = path4.resolve(process.cwd(), directory);
+  if (!isScaffolded(dir)) {
+    console.error(chalk4.red("\n\u274C Error: Not a Baseboards project"));
+    console.log(chalk4.gray("   Run"), chalk4.cyan("baseboards up"), chalk4.gray("to scaffold a project first."));
+    process.exit(1);
+  }
+  const args = ["compose", "logs"];
+  if (options.follow) {
+    args.push("--follow");
+  }
+  if (options.since) {
+    args.push("--since", options.since);
+  }
+  if (options.tail) {
+    args.push("--tail", options.tail);
+  }
+  if (services.length > 0) {
+    args.push(...services);
+  }
+  try {
+    await execa4("docker", args, {
+      cwd: dir,
+      stdio: "inherit"
+    });
+  } catch (error) {
+    if (error.signal !== "SIGINT") {
+      throw error;
+    }
+  }
+}
+
+// src/commands/status.ts
+import { execa as execa5 } from "execa";
+import path5 from "path";
+import chalk5 from "chalk";
+async function status(directory) {
+  const dir = path5.resolve(process.cwd(), directory);
+  if (!isScaffolded(dir)) {
+    console.error(chalk5.red("\n\u274C Error: Not a Baseboards project"));
+    console.log(chalk5.gray("   Run"), chalk5.cyan("baseboards up"), chalk5.gray("to scaffold a project first."));
+    process.exit(1);
+  }
+  console.log(chalk5.blue.bold("\n\u{1F4CA} Service Status\n"));
+  try {
+    await execa5("docker", ["compose", "ps"], {
+      cwd: dir,
+      stdio: "inherit"
+    });
+  } catch (error) {
+    console.error(chalk5.red("\n\u274C Failed to get status"));
+    throw error;
+  }
+}
+
+// src/commands/clean.ts
+import { execa as execa6 } from "execa";
+import path6 from "path";
+import chalk6 from "chalk";
+import ora3 from "ora";
+import prompts2 from "prompts";
+async function clean(directory, options) {
+  const dir = path6.resolve(process.cwd(), directory);
+  if (!isScaffolded(dir)) {
+    console.error(chalk6.red("\n\u274C Error: Not a Baseboards project"));
+    console.log(chalk6.gray("   Run"), chalk6.cyan("baseboards up"), chalk6.gray("to scaffold a project first."));
+    process.exit(1);
+  }
+  if (options.hard) {
+    console.log(chalk6.yellow("\n\u26A0\uFE0F  WARNING: This will delete:"));
+    console.log(chalk6.yellow("   \u2022 All containers"));
+    console.log(chalk6.yellow("   \u2022 All volumes (database data will be lost)"));
+    console.log(chalk6.yellow("   \u2022 All images"));
+    const response = await prompts2({
+      type: "confirm",
+      name: "confirmed",
+      message: "Are you sure?",
+      initial: false
+    });
+    if (!response.confirmed) {
+      console.log(chalk6.gray("\nCancelled"));
+      return;
+    }
+  }
+  const spinner = ora3("Cleaning up...").start();
+  try {
+    await execa6("docker", ["compose", "down", "--volumes", "--remove-orphans"], {
+      cwd: dir
+    });
+    if (options.hard) {
+      try {
+        const { stdout } = await execa6("docker", ["compose", "images", "-q"], {
+          cwd: dir
+        });
+        const imageIds = stdout.split("\n").filter(Boolean);
+        if (imageIds.length > 0) {
+          await execa6("docker", ["rmi", ...imageIds]);
+        }
+      } catch (e) {
+      }
+    }
+    spinner.succeed("Cleanup complete");
+    if (options.hard) {
+      console.log(chalk6.green("\n\u2728 All Docker resources removed"));
+      console.log(chalk6.gray("   Run"), chalk6.cyan("baseboards up"), chalk6.gray("to start fresh."));
+    } else {
+      console.log(chalk6.green("\n\u2728 Containers and volumes removed"));
+    }
+  } catch (error) {
+    spinner.fail("Cleanup failed");
+    throw error;
+  }
+}
+
+// src/commands/update.ts
+import path7 from "path";
+import chalk7 from "chalk";
+async function update(directory, options) {
+  const dir = path7.resolve(process.cwd(), directory);
+  if (!isScaffolded(dir)) {
+    console.error(chalk7.red("\n\u274C Error: Not a Baseboards project"));
+    console.log(chalk7.gray("   Run"), chalk7.cyan("baseboards up"), chalk7.gray("to scaffold a project first."));
+    process.exit(1);
+  }
+  console.log(chalk7.blue.bold("\n\u{1F504} Update Command\n"));
+  console.log(chalk7.yellow("\u26A0\uFE0F  This feature is coming soon!"));
+  console.log(chalk7.gray("\nFor now, to update:"));
+  console.log(chalk7.gray("1. Update the CLI:"), chalk7.cyan("npm install -g @weirdfingers/baseboards@latest"));
+  console.log(chalk7.gray("2. Pull new images:"), chalk7.cyan("docker compose pull"));
+  console.log(chalk7.gray("3. Restart:"), chalk7.cyan("baseboards down && baseboards up"));
+  console.log();
+}
+
+// src/commands/doctor.ts
+import path8 from "path";
+import fs3 from "fs-extra";
+import chalk8 from "chalk";
+async function doctor(directory) {
+  const dir = path8.resolve(process.cwd(), directory);
+  console.log(chalk8.blue.bold("\n\u{1FA7A} Baseboards Diagnostics\n"));
+  console.log(chalk8.cyan("CLI Version:"), getCliVersion());
+  console.log(chalk8.cyan("\n\u{1F4CB} Prerequisites:"));
+  const prereqs = await checkPrerequisites();
+  console.log(
+    chalk8.gray("  Node.js:"),
+    prereqs.node.installed ? prereqs.node.satisfies ? chalk8.green(`\u2713 v${prereqs.node.version}`) : chalk8.yellow(`\u26A0\uFE0F  v${prereqs.node.version} (need v20+)`) : chalk8.red("\u2717 Not installed")
+  );
+  console.log(
+    chalk8.gray("  Docker:"),
+    prereqs.docker.installed ? chalk8.green(`\u2713 v${prereqs.docker.version}`) : chalk8.red("\u2717 Not installed")
+  );
+  if (prereqs.docker.composeVersion) {
+    console.log(
+      chalk8.gray("  Docker Compose:"),
+      chalk8.green(`\u2713 v${prereqs.docker.composeVersion}`)
+    );
+  } else if (prereqs.docker.installed) {
+    console.log(chalk8.gray("  Docker Compose:"), chalk8.red("\u2717 Not available"));
+  }
+  console.log(chalk8.gray("  Platform:"), prereqs.platform.name);
+  if (prereqs.platform.isWSL) {
+    console.log(chalk8.gray("  WSL:"), chalk8.blue("\u2713 Detected"));
+  }
+  console.log(chalk8.cyan("\n\u{1F4C2} Project:"));
+  const scaffolded = isScaffolded(dir);
+  console.log(
+    chalk8.gray("  Scaffolded:"),
+    scaffolded ? chalk8.green("\u2713 Yes") : chalk8.yellow("\u2717 No")
+  );
+  if (scaffolded) {
+    console.log(chalk8.gray("  Directory:"), dir);
+    const webPkg = path8.join(dir, "web/package.json");
+    const apiPkg = path8.join(dir, "api/pyproject.toml");
+    const composeFile = path8.join(dir, "compose.yaml");
+    console.log(
+      chalk8.gray("  Web package:"),
+      fs3.existsSync(webPkg) ? chalk8.green("\u2713") : chalk8.red("\u2717")
+    );
+    console.log(
+      chalk8.gray("  API package:"),
+      fs3.existsSync(apiPkg) ? chalk8.green("\u2713") : chalk8.red("\u2717")
+    );
+    console.log(
+      chalk8.gray("  Compose file:"),
+      fs3.existsSync(composeFile) ? chalk8.green("\u2713") : chalk8.red("\u2717")
+    );
+    console.log(chalk8.cyan("\n\u{1F510} Environment:"));
+    const webEnv = path8.join(dir, "web/.env");
+    const apiEnv = path8.join(dir, "api/.env");
+    const dockerEnv = path8.join(dir, "docker/.env");
+    console.log(
+      chalk8.gray("  Web .env:"),
+      fs3.existsSync(webEnv) ? chalk8.green("\u2713") : chalk8.yellow("\u2717 Missing")
+    );
+    console.log(
+      chalk8.gray("  API .env:"),
+      fs3.existsSync(apiEnv) ? chalk8.green("\u2713") : chalk8.yellow("\u2717 Missing")
+    );
+    console.log(
+      chalk8.gray("  Docker .env:"),
+      fs3.existsSync(dockerEnv) ? chalk8.green("\u2713") : chalk8.yellow("\u2717 Missing")
+    );
+    if (fs3.existsSync(apiEnv)) {
+      const missingKeys = detectMissingProviderKeys(apiEnv);
+      if (missingKeys.length > 0) {
+        console.log(
+          chalk8.gray("  Provider keys:"),
+          chalk8.yellow(`\u26A0\uFE0F  ${missingKeys.length} missing`)
+        );
+        console.log(chalk8.gray("    Missing:"), missingKeys.map((k) => chalk8.cyan(k)).join(", "));
+      } else {
+        console.log(chalk8.gray("  Provider keys:"), chalk8.green("\u2713 Configured"));
+      }
+    }
+    console.log(chalk8.cyan("\n\u2699\uFE0F  Configuration:"));
+    const generatorsYaml = path8.join(dir, "api/config/generators.yaml");
+    const storageYaml = path8.join(dir, "api/config/storage_config.yaml");
+    console.log(
+      chalk8.gray("  generators.yaml:"),
+      fs3.existsSync(generatorsYaml) ? chalk8.green("\u2713") : chalk8.yellow("\u2717 Missing")
+    );
+    console.log(
+      chalk8.gray("  storage_config.yaml:"),
+      fs3.existsSync(storageYaml) ? chalk8.green("\u2713") : chalk8.yellow("\u2717 Missing")
+    );
+    const storageDir = path8.join(dir, "data/storage");
+    console.log(
+      chalk8.gray("  Storage directory:"),
+      fs3.existsSync(storageDir) ? chalk8.green("\u2713") : chalk8.yellow("\u2717 Missing")
+    );
+  }
+  console.log(chalk8.cyan("\n\u{1F4A1} Recommendations:"));
+  const recommendations = [];
+  if (!prereqs.node.satisfies) {
+    recommendations.push("Upgrade Node.js to v20 or higher");
+  }
+  if (!prereqs.docker.installed) {
+    recommendations.push("Install Docker Desktop: https://docs.docker.com/get-docker/");
+  } else if (!prereqs.docker.composeVersion) {
+    recommendations.push("Update Docker to get Compose v2");
+  }
+  if (!scaffolded) {
+    recommendations.push("Run " + chalk8.cyan("baseboards up") + " to scaffold a project");
+  }
+  if (recommendations.length === 0) {
+    console.log(chalk8.green("  \u2713 Everything looks good!"));
+  } else {
+    recommendations.forEach((rec) => console.log(chalk8.yellow("  \u2022"), rec));
+  }
+  console.log();
+}
+
+// src/index.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var packageJson = JSON.parse(
+  readFileSync(join(__dirname2, "../package.json"), "utf-8")
+);
+var program = new Command();
+program.name("baseboards").description(
+  "\u{1F3A8} One-command launcher for the Boards image generation platform"
+).version(packageJson.version, "-v, --version", "Output the current version");
+program.command("up").description("Start Baseboards (scaffolds if needed)").argument("[directory]", "Project directory", ".").option("--dev", "Development mode with hot reload (default)", true).option("--prod", "Production mode with prebuilt images").option("--detached", "Run in detached mode (background)").option("--ports <ports>", "Custom ports (e.g., web=3300 api=8800)").action(up);
+program.command("down").description("Stop Baseboards").argument("[directory]", "Project directory", ".").option("--volumes", "Also remove volumes").action(down);
+program.command("logs").description("View logs from services").argument("[directory]", "Project directory", ".").argument(
+  "[services...]",
+  "Services to show logs for (web, api, db, cache)",
+  []
+).option("-f, --follow", "Follow log output").option("--since <time>", "Show logs since timestamp (e.g., 1h, 30m)").option("--tail <lines>", "Number of lines to show from end", "100").action(logs);
+program.command("status").description("Show status of services").argument("[directory]", "Project directory", ".").action(status);
+program.command("clean").description("Clean up Docker resources").argument("[directory]", "Project directory", ".").option("--hard", "Remove volumes and images (WARNING: deletes data)").action(clean);
+program.command("update").description("Update Baseboards to latest version").argument("[directory]", "Project directory", ".").option("--force", "Force update without safety checks").option("--version <version>", "Update to specific version").action(update);
+program.command("doctor").description("Run diagnostics and show system info").argument("[directory]", "Project directory", ".").action(doctor);
+try {
+  await program.parseAsync(process.argv);
+} catch (error) {
+  const err = error;
+  console.error(chalk9.red("\n\u274C Error:"), err.message || "Unknown error");
+  if (err.stderr) {
+    console.error(chalk9.gray("\nDetails:"));
+    console.error(chalk9.gray(err.stderr));
+  }
+  console.error(
+    chalk9.yellow("\n\u{1F4A1} Try running:"),
+    chalk9.cyan("baseboards doctor")
+  );
+  console.error(
+    chalk9.yellow("\u{1F4D6} Documentation:"),
+    chalk9.cyan("https://baseboards.dev/docs")
+  );
+  process.exit(1);
+}
+//# sourceMappingURL=index.js.map