@onexapis/cli 1.0.0

package/dist/cli.mjs

@@ -0,0 +1,2492 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk4 from 'chalk';
+import path from 'path';
+import fs2 from 'fs';
+import { execSync, spawn } from 'child_process';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import fs from 'fs-extra';
+import ejs from 'ejs';
+import archiver from 'archiver';
+import FormData from 'form-data';
+import fetch from 'node-fetch';
+import { S3Client, PutObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3';
+import { glob } from 'glob';
+
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+var Logger = class {
+  constructor() {
+    this.spinner = null;
+  }
+  success(message) {
+    console.log(chalk4.green("\u2713"), message);
+  }
+  error(message) {
+    console.log(chalk4.red("\u2717"), message);
+  }
+  warning(message) {
+    console.log(chalk4.yellow("\u26A0"), message);
+  }
+  info(message) {
+    console.log(chalk4.blue("\u2139"), message);
+  }
+  log(message) {
+    console.log(message);
+  }
+  startSpinner(message) {
+    this.spinner = ora(message).start();
+  }
+  stopSpinner(success = true, message) {
+    if (!this.spinner) return;
+    if (success) {
+      this.spinner.succeed(message);
+    } else {
+      this.spinner.fail(message);
+    }
+    this.spinner = null;
+  }
+  updateSpinner(message) {
+    if (this.spinner) {
+      this.spinner.text = message;
+    }
+  }
+  newLine() {
+    console.log();
+  }
+  header(message) {
+    console.log();
+    console.log(chalk4.bold.cyan(message));
+    console.log(chalk4.cyan("=".repeat(message.length)));
+    console.log();
+  }
+  section(message) {
+    console.log();
+    console.log(chalk4.bold(message));
+  }
+};
+var logger = new Logger();
+
+// src/utils/validators.ts
+function validateName(name) {
+  return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(name);
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toPascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function validateThemeName(name) {
+  return /^[a-z][a-z0-9-]*$/.test(name);
+}
+function getValidCategories() {
+  return [
+    "headers",
+    "heroes",
+    "content",
+    "features",
+    "testimonials",
+    "galleries",
+    "cta",
+    "footers",
+    "ecommerce",
+    "blog",
+    "contact"
+  ];
+}
+async function renderTemplate(templatePath, data) {
+  const template = await fs.readFile(templatePath, "utf-8");
+  return ejs.render(template, data);
+}
+async function writeFile(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf-8");
+}
+function getTemplatesDir() {
+  const locations = [
+    path.join(__dirname, "../../templates"),
+    // Development
+    path.join(__dirname, "../templates"),
+    // Production (dist/)
+    path.join(process.cwd(), "templates"),
+    // Fallback
+    path.join(process.cwd(), "packages/cli/templates")
+    // Monorepo
+  ];
+  for (const location of locations) {
+    if (fs.existsSync(location)) {
+      return location;
+    }
+  }
+  throw new Error("Templates directory not found");
+}
+async function copyTemplate(templateName, targetDir, data) {
+  const templatesDir = getTemplatesDir();
+  const templateDir = path.join(templatesDir, templateName);
+  if (!fs.existsSync(templateDir)) {
+    throw new Error(
+      `Template "${templateName}" not found at ${templateDir}. Available templates: ${fs.readdirSync(templatesDir).join(", ")}`
+    );
+  }
+  await fs.ensureDir(targetDir);
+  const files = await fs.readdir(templateDir);
+  for (const file of files) {
+    const templatePath = path.join(templateDir, file);
+    const targetPath = path.join(targetDir, file);
+    const stat = await fs.stat(templatePath);
+    if (stat.isDirectory()) {
+      await copyTemplateDir(templatePath, targetPath, data);
+    } else if (file.endsWith(".ejs")) {
+      const content = await renderTemplate(templatePath, data);
+      const outputPath = targetPath.replace(/\.ejs$/, "");
+      await writeFile(outputPath, content);
+    } else {
+      await fs.copy(templatePath, targetPath);
+    }
+  }
+}
+async function copyTemplateDir(templateDir, targetDir, data) {
+  await fs.ensureDir(targetDir);
+  const files = await fs.readdir(templateDir);
+  for (const file of files) {
+    const templatePath = path.join(templateDir, file);
+    const targetPath = path.join(targetDir, file);
+    const stat = await fs.stat(templatePath);
+    if (stat.isDirectory()) {
+      await copyTemplateDir(templatePath, targetPath, data);
+    } else if (file.endsWith(".ejs")) {
+      const content = await renderTemplate(templatePath, data);
+      const outputPath = targetPath.replace(/\.ejs$/, "");
+      await writeFile(outputPath, content);
+    } else {
+      await fs.copy(templatePath, targetPath);
+    }
+  }
+}
+function getProjectRoot() {
+  let currentDir = process.cwd();
+  while (currentDir !== path.parse(currentDir).root) {
+    const packageJsonPath = path.join(currentDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = fs.readJsonSync(packageJsonPath);
+      if (packageJson.workspaces || fs.existsSync(path.join(currentDir, "src/themes")) || fs.existsSync(path.join(currentDir, "themes"))) {
+        return currentDir;
+      }
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return process.cwd();
+}
+function getThemesDir() {
+  try {
+    return path.join(getProjectRoot(), "src/themes");
+  } catch (e) {
+    return path.join(getProjectRoot(), "themes");
+  }
+}
+function getFeaturesDir() {
+  return path.join(getProjectRoot(), "src/features");
+}
+function isOneXProject() {
+  const root = getProjectRoot();
+  return fs.existsSync(path.join(root, "src/themes")) && fs.existsSync(path.join(root, "src/lib/registry"));
+}
+function ensureOneXProject() {
+  if (!isOneXProject()) {
+    logger.error(
+      "Not in a OneX project. Please run this command from a OneX project root."
+    );
+    process.exit(1);
+  }
+}
+function listThemes() {
+  const themesDir = getThemesDir();
+  if (!fs.existsSync(themesDir)) {
+    return [];
+  }
+  return fs.readdirSync(themesDir).filter((name) => {
+    const themePath = path.join(themesDir, name);
+    return fs.statSync(themePath).isDirectory() && fs.existsSync(path.join(themePath, "manifest.ts"));
+  });
+}
+function themeExists(themeName) {
+  const themePath = path.join(getThemesDir(), themeName);
+  return fs.existsSync(themePath) && fs.existsSync(path.join(themePath, "manifest.ts"));
+}
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.includes("pnpm")) return "pnpm";
+  if (userAgent.includes("yarn")) return "yarn";
+  if (userAgent.includes("bun")) return "bun";
+  const cwd = process.cwd();
+  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs.existsSync(path.join(cwd, "bun.lockb"))) return "bun";
+  return "npm";
+}
+async function installDependencies(projectPath, packageManager = "npm") {
+  return new Promise((resolve, reject) => {
+    try {
+      const installCmd = packageManager === "yarn" ? "yarn" : `${packageManager} install`;
+      execSync(installCmd, {
+        cwd: projectPath,
+        stdio: "inherit"
+      });
+      resolve();
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+// src/commands/init.ts
+async function initCommand(projectName, options = {}) {
+  logger.header("Create New OneX Theme Project");
+  let name;
+  if (!projectName) {
+    const { inputName } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "inputName",
+        message: "Project name (kebab-case):",
+        validate: (input) => {
+          if (!input) return "Project name is required";
+          const kebabName = toKebabCase(input);
+          if (!validateThemeName(kebabName)) {
+            return "Invalid project name. Use lowercase letters, numbers, and hyphens only.";
+          }
+          if (fs2.existsSync(path.join(process.cwd(), kebabName))) {
+            return `Directory "${kebabName}" already exists`;
+          }
+          return true;
+        }
+      }
+    ]);
+    name = toKebabCase(inputName);
+  } else {
+    name = toKebabCase(projectName);
+  }
+  const projectPath = path.join(process.cwd(), name);
+  if (fs2.existsSync(projectPath)) {
+    logger.error(`Directory "${name}" already exists.`);
+    process.exit(1);
+  }
+  let displayName;
+  let description;
+  let author;
+  let template;
+  if (options.yes) {
+    displayName = toPascalCase(name).replace(/([A-Z])/g, " $1").trim();
+    description = "A custom OneX theme";
+    author = "";
+    template = options.template || "default";
+  } else {
+    const answers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "displayName",
+        message: "Display name:",
+        default: toPascalCase(name).replace(/([A-Z])/g, " $1").trim()
+      },
+      {
+        type: "input",
+        name: "description",
+        message: "Theme description:",
+        default: "A custom OneX theme"
+      },
+      {
+        type: "input",
+        name: "author",
+        message: "Author name:",
+        default: ""
+      },
+      {
+        type: "list",
+        name: "template",
+        message: "Template to use:",
+        choices: [
+          { name: "Default (basic theme structure)", value: "default" },
+          { name: "Minimal (bare minimum)", value: "minimal" }
+        ],
+        default: options.template || "default"
+      }
+    ]);
+    displayName = answers.displayName;
+    description = answers.description;
+    author = answers.author;
+    template = answers.template;
+  }
+  const data = {
+    projectName: name,
+    themeName: name,
+    themeNamePascal: toPascalCase(name),
+    displayName,
+    description,
+    author,
+    template
+  };
+  logger.startSpinner("Creating project structure...");
+  try {
+    fs2.mkdirSync(projectPath, { recursive: true });
+    await copyTemplate(template, projectPath, data);
+    const srcPath = path.join(projectPath, "src");
+    fs2.mkdirSync(srcPath, { recursive: true });
+    const manifestContent = generateManifest(data);
+    await writeFile(path.join(srcPath, "manifest.ts"), manifestContent);
+    const configContent = generateThemeConfig(data);
+    await writeFile(path.join(srcPath, "config.ts"), configContent);
+    const layoutContent = generateThemeLayout(data);
+    await writeFile(path.join(srcPath, "layout.ts"), layoutContent);
+    const indexContent = generateThemeIndex(data);
+    await writeFile(path.join(srcPath, "index.ts"), indexContent);
+    const sectionsPath = path.join(srcPath, "sections");
+    fs2.mkdirSync(sectionsPath, { recursive: true });
+    await writeFile(
+      path.join(sectionsPath, "README.md"),
+      `# ${displayName} Sections
+
+Add your theme-specific sections here.
+`
+    );
+    const blocksPath = path.join(srcPath, "blocks");
+    fs2.mkdirSync(blocksPath, { recursive: true });
+    await writeFile(
+      path.join(blocksPath, "README.md"),
+      `# ${displayName} Blocks
+
+Add your theme-specific blocks here.
+`
+    );
+    const pagesPath = path.join(srcPath, "pages");
+    fs2.mkdirSync(pagesPath, { recursive: true });
+    const homePageContent = generateHomePage(data);
+    await writeFile(path.join(pagesPath, "home.ts"), homePageContent);
+    logger.stopSpinner(true, "Project structure created!");
+    if (options.git) {
+      logger.startSpinner("Initializing git repository...");
+      try {
+        execSync("git init", { cwd: projectPath, stdio: "ignore" });
+        execSync("git add .", { cwd: projectPath, stdio: "ignore" });
+        execSync('git commit -m "Initial commit from onex init"', {
+          cwd: projectPath,
+          stdio: "ignore"
+        });
+        logger.stopSpinner(true, "Git repository initialized!");
+      } catch (e) {
+        logger.stopSpinner(false, "Failed to initialize git");
+      }
+    }
+    if (!options.noInstall) {
+      logger.newLine();
+      const packageManager = detectPackageManager();
+      logger.startSpinner(`Installing dependencies with ${packageManager}...`);
+      try {
+        await installDependencies(projectPath, packageManager);
+        logger.stopSpinner(true, "Dependencies installed!");
+      } catch (e) {
+        logger.stopSpinner(false, "Failed to install dependencies");
+        logger.info(
+          "You can install dependencies manually by running: cd " + name + " && npm install"
+        );
+      }
+    }
+    logger.newLine();
+    logger.section("Success! \u{1F389}");
+    logger.newLine();
+    logger.info(`Created OneX theme project at: ${projectPath}`);
+    logger.newLine();
+    logger.section("Next steps:");
+    logger.log(`  cd ${name}`);
+    if (options.noInstall) {
+      logger.log(`  npm install`);
+    }
+    logger.log(`  npm run build      # Build your theme`);
+    logger.log(`  npm run dev        # Start development mode`);
+    logger.newLine();
+    logger.section("Theme structure:");
+    logger.log("  src/manifest.ts    - Theme manifest and exports");
+    logger.log("  src/config.ts      - Design tokens (colors, typography, etc.)");
+    logger.log("  src/layout.ts      - Header and footer configuration");
+    logger.log("  src/sections/      - Custom sections for your theme");
+    logger.log("  src/blocks/        - Reusable blocks");
+    logger.log("  src/pages/         - Page configurations");
+    logger.newLine();
+    logger.success(`Happy theming! \u{1F3A8}`);
+  } catch (error) {
+    logger.stopSpinner(false, "Failed to create project");
+    logger.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    if (fs2.existsSync(projectPath)) {
+      fs2.rmSync(projectPath, { recursive: true, force: true });
+    }
+    process.exit(1);
+  }
+}
+function generateManifest(data) {
+  return `import type { ThemeExport } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Theme Manifest
+ * ${data.description}
+ */
+export const manifest: ThemeExport = {
+  id: "${data.themeName}",
+  name: "${data.displayName}",
+  description: "${data.description}",
+  version: "1.0.0",
+  author: "${data.author}",
+
+  // Theme configuration
+  config: () => import("./theme.config").then((m) => m.themeConfig),
+
+  // Theme layout (header/footer sections)
+  layout: () => import("./theme.layout").then((m) => m.themeLayout),
+
+  // Available sections in this theme
+  sections: {
+    // Example: hero: () => import("./sections/hero").then((m) => m.heroSchema),
+  },
+
+  // Available blocks in this theme
+  blocks: {
+    // Example: productCard: () => import("./blocks/product-card").then((m) => m.productCardDefinition),
+  },
+
+  // Default pages
+  pages: {
+    home: () => import("./pages/home").then((m) => m.homePageConfig),
+  },
+
+  // Supported page types
+  supportedPageTypes: ["home", "about", "contact", "custom"],
+
+  // Preview image (optional)
+  preview: undefined,
+
+  // Tags for categorization (optional)
+  tags: ["custom"],
+};
+
+export default manifest;
+`;
+}
+function generateThemeConfig(data) {
+  return `import type { ThemeConfig } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Theme Configuration
+ * Design tokens: colors, typography, spacing, etc.
+ */
+export const themeConfig: ThemeConfig = {
+  // Color palette
+  colors: {
+    primary: {
+      50: "#eff6ff",
+      100: "#dbeafe",
+      200: "#bfdbfe",
+      300: "#93c5fd",
+      400: "#60a5fa",
+      500: "#3b82f6",
+      600: "#2563eb",
+      700: "#1d4ed8",
+      800: "#1e40af",
+      900: "#1e3a8a",
+    },
+    secondary: {
+      50: "#f8fafc",
+      100: "#f1f5f9",
+      200: "#e2e8f0",
+      300: "#cbd5e1",
+      400: "#94a3b8",
+      500: "#64748b",
+      600: "#475569",
+      700: "#334155",
+      800: "#1e293b",
+      900: "#0f172a",
+    },
+    accent: {
+      50: "#fdf4ff",
+      100: "#fae8ff",
+      200: "#f5d0fe",
+      300: "#f0abfc",
+      400: "#e879f9",
+      500: "#d946ef",
+      600: "#c026d3",
+      700: "#a21caf",
+      800: "#86198f",
+      900: "#701a75",
+    },
+  },
+
+  // Typography
+  typography: {
+    fontFamily: {
+      sans: ["Inter", "system-ui", "sans-serif"],
+      serif: ["Georgia", "serif"],
+      mono: ["Monaco", "monospace"],
+    },
+    fontSize: {
+      xs: "0.75rem",
+      sm: "0.875rem",
+      base: "1rem",
+      lg: "1.125rem",
+      xl: "1.25rem",
+      "2xl": "1.5rem",
+      "3xl": "1.875rem",
+      "4xl": "2.25rem",
+      "5xl": "3rem",
+    },
+  },
+
+  // Spacing
+  spacing: {
+    xs: "0.5rem",
+    sm: "1rem",
+    md: "1.5rem",
+    lg: "2rem",
+    xl: "3rem",
+    "2xl": "4rem",
+    "3xl": "6rem",
+    "4xl": "8rem",
+  },
+
+  // Border radius
+  borderRadius: {
+    none: "0",
+    sm: "0.125rem",
+    md: "0.375rem",
+    lg: "0.5rem",
+    xl: "0.75rem",
+    full: "9999px",
+  },
+
+  // Breakpoints
+  breakpoints: {
+    sm: "640px",
+    md: "768px",
+    lg: "1024px",
+    xl: "1280px",
+    "2xl": "1536px",
+  },
+};
+`;
+}
+function generateThemeLayout(data) {
+  return `import type { ThemeLayoutConfig } from "@duongthiu/onex-core";
+
+/**
+ * ${data.themeName} Theme Layout
+ * Define header and footer sections
+ */
+export const themeLayout: ThemeLayoutConfig = {
+  // Header section configuration
+  header: undefined,
+  // Example:
+  // header: {
+  //   type: "header",
+  //   template: "default",
+  //   enabled: true,
+  //   settings: {},
+  // },
+
+  // Footer section configuration
+  footer: undefined,
+  // Example:
+  // footer: {
+  //   type: "footer",
+  //   template: "default",
+  //   enabled: true,
+  //   settings: {},
+  // },
+};
+`;
+}
+function generateThemeIndex(data) {
+  return `/**
+ * ${data.themeNamePascal} Theme
+ */
+
+export { manifest as ${data.themeName}Manifest } from "./manifest";
+export { themeConfig as ${data.themeName}Config } from "./theme.config";
+export { themeLayout as ${data.themeName}Layout } from "./theme.layout";
+`;
+}
+function generateHomePage(data) {
+  return `import type { PageConfig } from "@duongthiu/onex-core";
+
+/**
+ * Home Page Configuration
+ */
+export const homePageConfig: PageConfig = {
+  type: "home",
+  title: "${data.displayName}",
+  description: "Welcome to ${data.displayName}",
+
+  // SEO metadata
+  seo: {
+    title: "${data.displayName} - Home",
+    description: "Welcome to ${data.displayName}",
+    keywords: [],
+    ogImage: undefined,
+  },
+
+  // Page sections
+  sections: [
+    // Add your sections here
+    // Example:
+    // {
+    //   id: "hero-1",
+    //   type: "hero",
+    //   template: "default",
+    //   order: 0,
+    //   enabled: true,
+    //   settings: {},
+    //   components: [],
+    //   blocks: [],
+    // },
+  ],
+};
+`;
+}
+async function createSectionCommand(name, options) {
+  logger.header("Create New Section");
+  ensureOneXProject();
+  const sectionName = toKebabCase(name);
+  if (!validateName(sectionName)) {
+    logger.error(
+      `Invalid section name: ${sectionName}. Use kebab-case (e.g., hero, featured-products)`
+    );
+    process.exit(1);
+  }
+  const answers = await inquirer.prompt([
+    {
+      type: "list",
+      name: "theme",
+      message: "Which theme should this section belong to?",
+      choices: listThemes(),
+      when: !options.theme
+    },
+    {
+      type: "list",
+      name: "category",
+      message: "What category is this section?",
+      choices: getValidCategories(),
+      when: !options.category
+    },
+    {
+      type: "input",
+      name: "displayName",
+      message: "Display name for this section:",
+      default: toPascalCase(sectionName).replace(/([A-Z])/g, " $1").trim()
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Section description:",
+      default: `${toPascalCase(sectionName)} section`
+    },
+    {
+      type: "confirm",
+      name: "createTemplate",
+      message: "Create a default template variant?",
+      default: true
+    }
+  ]);
+  const themeName = options.theme || answers.theme;
+  const category = options.category || answers.category;
+  const displayName = answers.displayName;
+  const description = answers.description;
+  const createTemplate = answers.createTemplate;
+  if (!themeExists(themeName)) {
+    logger.error(`Theme "${themeName}" does not exist.`);
+    process.exit(1);
+  }
+  const data = {
+    sectionName,
+    sectionNamePascal: toPascalCase(sectionName),
+    themeName,
+    category,
+    displayName,
+    description
+  };
+  logger.startSpinner("Creating section files...");
+  try {
+    const themePath = path.join(getThemesDir(), themeName);
+    const sectionPath = path.join(themePath, "sections", sectionName);
+    const schemaContent = generateSectionSchema(data);
+    await writeFile(
+      path.join(sectionPath, `${sectionName}.schema.ts`),
+      schemaContent
+    );
+    if (createTemplate) {
+      const templateContent = generateSectionTemplate(data);
+      await writeFile(
+        path.join(sectionPath, `${sectionName}-default.tsx`),
+        templateContent
+      );
+    }
+    const indexContent = generateSectionIndex(data, createTemplate);
+    await writeFile(path.join(sectionPath, "index.ts"), indexContent);
+    logger.stopSpinner(true, "Section files created successfully!");
+    logger.newLine();
+    logger.section("Next steps:");
+    logger.log(
+      `  1. Edit schema: ${path.relative(process.cwd(), path.join(sectionPath, `${sectionName}.schema.ts`))}`
+    );
+    if (createTemplate) {
+      logger.log(
+        `  2. Edit template: ${path.relative(process.cwd(), path.join(sectionPath, `${sectionName}-default.tsx`))}`
+      );
+    }
+    logger.log(
+      `  3. Add to theme manifest: ${path.relative(process.cwd(), path.join(themePath, "manifest.ts"))}`
+    );
+    logger.newLine();
+    logger.success("Section created successfully!");
+  } catch (error) {
+    logger.stopSpinner(false, "Failed to create section");
+    logger.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    process.exit(1);
+  }
+}
+function generateSectionSchema(data) {
+  return `import type { SectionSchema } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Section Schema
+ * ${data.description}
+ */
+export const ${data.sectionName}Schema: SectionSchema = {
+  type: "${data.sectionName}",
+  name: "${data.displayName}",
+  description: "${data.description}",
+  category: "${data.category}",
+  icon: "layout",
+
+  // Available template variants
+  templates: [
+    {
+      id: "default",
+      name: "Default",
+      description: "Default ${data.sectionName} layout",
+      isDefault: true,
+    },
+  ],
+
+  // Section-level settings
+  settings: [
+    {
+      id: "backgroundColor",
+      type: "color",
+      label: "Background Color",
+      category: "style",
+    },
+    {
+      id: "padding",
+      type: "select",
+      label: "Padding",
+      category: "style",
+      options: [
+        { label: "None", value: "none" },
+        { label: "Small", value: "sm" },
+        { label: "Medium", value: "md" },
+        { label: "Large", value: "lg" },
+      ],
+      defaultValue: "md",
+    },
+  ],
+
+  // Default settings values
+  defaults: {
+    backgroundColor: "#ffffff",
+    padding: "md",
+  },
+
+  // Allowed blocks (optional)
+  allowedBlocks: [],
+
+  // Maximum number of instances on a page (optional)
+  maxInstances: undefined,
+};
+`;
+}
+function generateSectionTemplate(data) {
+  return `import React from "react";
+import type { SectionComponentProps } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} - Default Template
+ */
+export function ${data.sectionNamePascal}Default({
+  section,
+  isEditing = false,
+}: SectionComponentProps) {
+  const { settings = {} } = section;
+  const backgroundColor = settings.backgroundColor as string || "#ffffff";
+  const padding = settings.padding as string || "md";
+
+  // Map padding values to Tailwind classes
+  const paddingClasses = {
+    none: "",
+    sm: "py-8",
+    md: "py-16",
+    lg: "py-24",
+  };
+
+  return (
+    <section
+      className={\`${data.sectionName}-section \${paddingClasses[padding as keyof typeof paddingClasses] || paddingClasses.md}\`}
+      style={{ backgroundColor }}
+      data-section-id={section.id}
+      data-section-type={section.type}
+    >
+      <div className="container mx-auto px-4">
+        {/* TODO: Implement section content */}
+        <div className="text-center">
+          <h2 className="text-3xl font-bold">${data.displayName}</h2>
+          <p className="mt-4 text-gray-600">
+            Start building your section here
+          </p>
+        </div>
+
+        {/* Render blocks if any */}
+        {section.blocks && section.blocks.length > 0 && (
+          <div className="mt-8">
+            {/* TODO: Render blocks */}
+          </div>
+        )}
+
+        {/* Render components if any */}
+        {section.components && section.components.length > 0 && (
+          <div className="mt-8">
+            {/* TODO: Render components */}
+          </div>
+        )}
+      </div>
+    </section>
+  );
+}
+`;
+}
+function generateSectionIndex(data, hasTemplate) {
+  return `/**
+ * ${data.sectionNamePascal} Section
+ */
+
+export { ${data.sectionName}Schema } from "./${data.sectionName}.schema";
+${hasTemplate ? `export { ${data.sectionNamePascal}Default } from "./${data.sectionName}-default";` : ""}
+`;
+}
+async function createBlockCommand(name, options) {
+  logger.header("Create New Block");
+  ensureOneXProject();
+  const blockName = toKebabCase(name);
+  if (!validateName(blockName)) {
+    logger.error(
+      `Invalid block name: ${blockName}. Use kebab-case (e.g., product-card, testimonial-item)`
+    );
+    process.exit(1);
+  }
+  const answers = await inquirer.prompt([
+    {
+      type: "list",
+      name: "scope",
+      message: "Block scope:",
+      choices: [
+        { name: "Shared (available to all themes)", value: "shared" },
+        { name: "Theme-specific", value: "theme" }
+      ],
+      default: "shared"
+    },
+    {
+      type: "list",
+      name: "theme",
+      message: "Which theme?",
+      choices: listThemes(),
+      when: (answers2) => answers2.scope === "theme" && !options.theme
+    },
+    {
+      type: "input",
+      name: "displayName",
+      message: "Display name for this block:",
+      default: toPascalCase(blockName).replace(/([A-Z])/g, " $1").trim()
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Block description:",
+      default: `${toPascalCase(blockName)} block`
+    },
+    {
+      type: "confirm",
+      name: "hasComponents",
+      message: "Does this block contain components?",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "hasNestedBlocks",
+      message: "Does this block support nested blocks?",
+      default: false
+    }
+  ]);
+  const scope = answers.scope;
+  const themeName = options.theme || answers.theme;
+  const displayName = answers.displayName;
+  const description = answers.description;
+  const hasComponents = answers.hasComponents;
+  const hasNestedBlocks = answers.hasNestedBlocks;
+  if (scope === "theme" && !themeExists(themeName)) {
+    logger.error(`Theme "${themeName}" does not exist.`);
+    process.exit(1);
+  }
+  const data = {
+    blockName,
+    blockNamePascal: toPascalCase(blockName),
+    displayName,
+    description,
+    hasComponents,
+    hasNestedBlocks,
+    scope,
+    themeName
+  };
+  logger.startSpinner("Creating block files...");
+  try {
+    const blockPath = scope === "shared" ? path.join(getFeaturesDir(), "blocks", blockName) : path.join(getThemesDir(), themeName, "blocks", blockName);
+    const schemaContent = generateBlockSchema(data);
+    await writeFile(
+      path.join(blockPath, `${blockName}.schema.ts`),
+      schemaContent
+    );
+    const componentContent = generateBlockComponent(data);
+    await writeFile(path.join(blockPath, `${blockName}.tsx`), componentContent);
+    const indexContent = generateBlockIndex(data);
+    await writeFile(path.join(blockPath, "index.ts"), indexContent);
+    logger.stopSpinner(true, "Block files created successfully!");
+    logger.newLine();
+    logger.section("Next steps:");
+    logger.log(
+      `  1. Edit schema: ${path.relative(process.cwd(), path.join(blockPath, `${blockName}.schema.ts`))}`
+    );
+    logger.log(
+      `  2. Edit component: ${path.relative(process.cwd(), path.join(blockPath, `${blockName}.tsx`))}`
+    );
+    logger.log(
+      `  3. Register in block registry: src/lib/registry/block-registry.ts`
+    );
+    logger.newLine();
+    logger.success("Block created successfully!");
+  } catch (error) {
+    logger.stopSpinner(false, "Failed to create block");
+    logger.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    process.exit(1);
+  }
+}
+function generateBlockSchema(data) {
+  return `import type { BlockDefinition } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Block Schema
+ * ${data.description}
+ */
+export const ${data.blockName}Definition: BlockDefinition = {
+  type: "${data.blockName}",
+  name: "${data.displayName}",
+  description: "${data.description}",
+  icon: "square",
+
+  // Block settings
+  settings: [
+    {
+      id: "title",
+      type: "text",
+      label: "Title",
+      category: "content",
+    },
+    {
+      id: "alignment",
+      type: "select",
+      label: "Alignment",
+      category: "style",
+      options: [
+        { label: "Left", value: "left" },
+        { label: "Center", value: "center" },
+        { label: "Right", value: "right" },
+      ],
+      defaultValue: "left",
+    },
+  ],
+
+  // Default settings values
+  defaults: {
+    title: "${data.displayName}",
+    alignment: "left",
+  },
+
+  ${data.hasComponents ? `// This block can contain components
+  allowsComponents: true,` : ""}
+  ${data.hasNestedBlocks ? `// This block can contain nested blocks
+  allowsNestedBlocks: true,` : ""}
+};
+`;
+}
+function generateBlockComponent(data) {
+  return `import React from "react";
+import type { BlockComponentProps } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Block Component
+ */
+export function ${data.blockNamePascal}({
+  block,
+  isEditing = false,
+}: BlockComponentProps) {
+  const { settings = {} } = block;
+  const title = settings.title as string || "${data.displayName}";
+  const alignment = settings.alignment as string || "left";
+
+  const alignmentClasses = {
+    left: "text-left",
+    center: "text-center",
+    right: "text-right",
+  };
+
+  return (
+    <div
+      className={\`${data.blockName}-block \${alignmentClasses[alignment as keyof typeof alignmentClasses]}\`}
+      data-block-id={block.id}
+      data-block-type={block.type}
+    >
+      {title && <h3 className="text-xl font-semibold mb-4">{title}</h3>}
+
+      {/* TODO: Implement block content */}
+      <div className="block-content">
+        <p className="text-gray-600">Block content goes here</p>
+      </div>
+
+      ${data.hasComponents ? `{/* Render components if any */}
+      {block.components && block.components.length > 0 && (
+        <div className="block-components mt-4">
+          {/* TODO: Render components using ComponentRenderer */}
+        </div>
+      )}` : ""}
+
+      ${data.hasNestedBlocks ? `{/* Render nested blocks if any */}
+      {block.blocks && block.blocks.length > 0 && (
+        <div className="nested-blocks mt-4">
+          {/* TODO: Render nested blocks using BlockRenderer */}
+        </div>
+      )}` : ""}
+    </div>
+  );
+}
+`;
+}
+function generateBlockIndex(data) {
+  return `/**
+ * ${data.blockNamePascal} Block
+ */
+
+export { ${data.blockName}Definition } from "./${data.blockName}.schema";
+export { ${data.blockNamePascal} } from "./${data.blockName}";
+`;
+}
+async function createComponentCommand(name, options) {
+  logger.header("Create New Component");
+  ensureOneXProject();
+  const componentName = toKebabCase(name);
+  if (!validateName(componentName)) {
+    logger.error(
+      `Invalid component name: ${componentName}. Use kebab-case (e.g., button, icon-badge)`
+    );
+    process.exit(1);
+  }
+  const answers = await inquirer.prompt([
+    {
+      type: "list",
+      name: "componentType",
+      message: "Component type:",
+      choices: [
+        { name: "UI Component (button, badge, etc.)", value: "ui" },
+        { name: "Form Component (input, select, etc.)", value: "form" },
+        { name: "Layout Component (container, grid, etc.)", value: "layout" },
+        {
+          name: "Content Component (heading, paragraph, etc.)",
+          value: "content"
+        }
+      ],
+      when: !options.type
+    },
+    {
+      type: "input",
+      name: "displayName",
+      message: "Display name for this component:",
+      default: toPascalCase(componentName).replace(/([A-Z])/g, " $1").trim()
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Component description:",
+      default: `${toPascalCase(componentName)} component`
+    }
+  ]);
+  const componentType = options.type || answers.componentType;
+  const displayName = answers.displayName;
+  const description = answers.description;
+  const data = {
+    componentName,
+    componentNamePascal: toPascalCase(componentName),
+    componentType,
+    displayName,
+    description
+  };
+  logger.startSpinner("Creating component files...");
+  try {
+    const componentPath = path.join(
+      getFeaturesDir(),
+      "components",
+      componentName
+    );
+    const schemaContent = generateComponentSchema(data);
+    await writeFile(
+      path.join(componentPath, `${componentName}.schema.ts`),
+      schemaContent
+    );
+    const componentContent = generateComponent(data);
+    await writeFile(
+      path.join(componentPath, `${componentName}.tsx`),
+      componentContent
+    );
+    const indexContent = generateComponentIndex(data);
+    await writeFile(path.join(componentPath, "index.ts"), indexContent);
+    logger.stopSpinner(true, "Component files created successfully!");
+    logger.newLine();
+    logger.section("Next steps:");
+    logger.log(
+      `  1. Edit schema: ${path.relative(process.cwd(), path.join(componentPath, `${componentName}.schema.ts`))}`
+    );
+    logger.log(
+      `  2. Edit component: ${path.relative(process.cwd(), path.join(componentPath, `${componentName}.tsx`))}`
+    );
+    logger.log(
+      `  3. Register in component registry: src/lib/registry/component-registry.ts`
+    );
+    logger.newLine();
+    logger.success("Component created successfully!");
+  } catch (error) {
+    logger.stopSpinner(false, "Failed to create component");
+    logger.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    process.exit(1);
+  }
+}
+function generateComponentSchema(data) {
+  return `import type { ComponentDefinition } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Component Schema
+ * ${data.description}
+ */
+export const ${data.componentName}Definition: ComponentDefinition = {
+  type: "${data.componentName}",
+  name: "${data.displayName}",
+  description: "${data.description}",
+  category: "${data.componentType}",
+  icon: "square",
+
+  // Content fields (what the component displays)
+  contentFields: [
+    {
+      id: "text",
+      type: "text",
+      label: "Text",
+      defaultValue: "${data.displayName}",
+    },
+  ],
+
+  // Style fields (how the component looks)
+  styleFields: [
+    {
+      id: "variant",
+      type: "select",
+      label: "Variant",
+      options: [
+        { label: "Default", value: "default" },
+        { label: "Primary", value: "primary" },
+        { label: "Secondary", value: "secondary" },
+      ],
+      defaultValue: "default",
+    },
+    {
+      id: "size",
+      type: "select",
+      label: "Size",
+      options: [
+        { label: "Small", value: "sm" },
+        { label: "Medium", value: "md" },
+        { label: "Large", value: "lg" },
+      ],
+      defaultValue: "md",
+    },
+  ],
+
+  // Default content values
+  defaultContent: {
+    text: "${data.displayName}",
+  },
+
+  // Default style values
+  defaultStyle: {
+    variant: "default",
+    size: "md",
+  },
+};
+`;
+}
+function generateComponent(data) {
+  return `import React from "react";
+import type { ComponentProps } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Component
+ */
+export function ${data.componentNamePascal}({
+  component,
+  isEditing = false,
+}: ComponentProps) {
+  const { content = {}, style = {} } = component;
+  const text = content.text as string || "${data.displayName}";
+  const variant = style.variant as string || "default";
+  const size = style.size as string || "md";
+
+  // Variant classes
+  const variantClasses = {
+    default: "bg-gray-100 text-gray-900",
+    primary: "bg-blue-600 text-white",
+    secondary: "bg-gray-600 text-white",
+  };
+
+  // Size classes
+  const sizeClasses = {
+    sm: "text-sm px-3 py-1",
+    md: "text-base px-4 py-2",
+    lg: "text-lg px-6 py-3",
+  };
+
+  return (
+    <div
+      className={\`${data.componentName} \${variantClasses[variant as keyof typeof variantClasses]} \${sizeClasses[size as keyof typeof sizeClasses]} inline-block rounded\`}
+      data-component-id={component.id}
+      data-component-type={component.type}
+    >
+      {text}
+    </div>
+  );
+}
+`;
+}
+function generateComponentIndex(data) {
+  return `/**
+ * ${data.componentNamePascal} Component
+ */
+
+export { ${data.componentName}Definition } from "./${data.componentName}.schema";
+export { ${data.componentNamePascal} } from "./${data.componentName}";
+`;
+}
+async function listCommand(options) {
+  logger.header("OneX Project Inventory");
+  ensureOneXProject();
+  const showAll = !options.sections && !options.blocks && !options.components;
+  if (showAll || options.sections) {
+    await listSections(options.theme);
+  }
+  if (showAll || options.blocks) {
+    await listBlocks(options.theme);
+  }
+  if (showAll || options.components) {
+    await listComponents();
+  }
+  if (showAll) {
+    await listThemesInfo();
+  }
+}
+async function listSections(themeFilter) {
+  logger.section("\u{1F4C4} Sections");
+  const themes = themeFilter ? [themeFilter] : listThemes();
+  if (themes.length === 0) {
+    logger.warning("No themes found");
+    return;
+  }
+  for (const theme of themes) {
+    const sectionsDir = path.join(getThemesDir(), theme, "sections");
+    if (!fs.existsSync(sectionsDir)) {
+      continue;
+    }
+    const sections = fs.readdirSync(sectionsDir).filter((name) => {
+      const sectionPath = path.join(sectionsDir, name);
+      return fs.statSync(sectionPath).isDirectory() && fs.existsSync(path.join(sectionPath, "index.ts"));
+    });
+    if (sections.length > 0) {
+      logger.log(chalk4.cyan(`
+  ${theme}:`));
+      sections.forEach((section) => {
+        logger.log(`    \u2022 ${section}`);
+      });
+    }
+  }
+  logger.newLine();
+}
+async function listBlocks(themeFilter) {
+  logger.section("\u{1F9F1} Blocks");
+  const sharedBlocksDir = path.join(getFeaturesDir(), "blocks");
+  if (fs.existsSync(sharedBlocksDir)) {
+    const sharedBlocks = fs.readdirSync(sharedBlocksDir).filter((name) => {
+      const blockPath = path.join(sharedBlocksDir, name);
+      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path.join(blockPath, "index.ts"));
+    });
+    if (sharedBlocks.length > 0) {
+      logger.log(chalk4.cyan("\n  Shared:"));
+      sharedBlocks.forEach((block) => {
+        logger.log(`    \u2022 ${block}`);
+      });
+    }
+  }
+  const themes = themeFilter ? [themeFilter] : listThemes();
+  for (const theme of themes) {
+    const blocksDir = path.join(getThemesDir(), theme, "blocks");
+    if (!fs.existsSync(blocksDir)) {
+      continue;
+    }
+    const blocks = fs.readdirSync(blocksDir).filter((name) => {
+      const blockPath = path.join(blocksDir, name);
+      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path.join(blockPath, "index.ts"));
+    });
+    if (blocks.length > 0) {
+      logger.log(chalk4.cyan(`
+  ${theme}:`));
+      blocks.forEach((block) => {
+        logger.log(`    \u2022 ${block}`);
+      });
+    }
+  }
+  logger.newLine();
+}
+async function listComponents() {
+  logger.section("\u2699\uFE0F  Components");
+  const componentsDir = path.join(getFeaturesDir(), "components");
+  if (!fs.existsSync(componentsDir)) {
+    logger.warning("No components directory found");
+    return;
+  }
+  const components = fs.readdirSync(componentsDir).filter((name) => {
+    const componentPath = path.join(componentsDir, name);
+    return fs.statSync(componentPath).isDirectory() && fs.existsSync(path.join(componentPath, "index.ts"));
+  });
+  if (components.length === 0) {
+    logger.warning("No components found");
+    return;
+  }
+  logger.log("");
+  components.forEach((component) => {
+    logger.log(`  \u2022 ${component}`);
+  });
+  logger.newLine();
+}
+async function listThemesInfo() {
+  logger.section("\u{1F3A8} Themes");
+  const themes = listThemes();
+  if (themes.length === 0) {
+    logger.warning("No themes found");
+    return;
+  }
+  logger.log("");
+  for (const theme of themes) {
+    const manifestPath = path.join(getThemesDir(), theme, "manifest.ts");
+    const manifestContent = fs.readFileSync(manifestPath, "utf-8");
+    const nameMatch = manifestContent.match(/name:\s*["'](.+)["']/);
+    const versionMatch = manifestContent.match(/version:\s*["'](.+)["']/);
+    const descMatch = manifestContent.match(/description:\s*["'](.+)["']/);
+    const displayName = nameMatch ? nameMatch[1] : theme;
+    const version = versionMatch ? versionMatch[1] : "unknown";
+    const description = descMatch ? descMatch[1] : "";
+    logger.log(chalk4.cyan(`  ${displayName}`) + chalk4.gray(` (v${version})`));
+    if (description) {
+      logger.log(chalk4.gray(`    ${description}`));
+    }
+  }
+  logger.newLine();
+}
+async function validateCommand(options) {
+  logger.header("Validate Theme");
+  ensureOneXProject();
+  const issues = [];
+  let themeToValidate;
+  if (options.theme) {
+    if (!themeExists(options.theme)) {
+      logger.error(`Theme "${options.theme}" not found.`);
+      process.exit(1);
+    }
+    themeToValidate = options.theme;
+  } else {
+    const manifestPath2 = path.join(process.cwd(), "manifest.ts");
+    if (fs.existsSync(manifestPath2)) {
+      themeToValidate = path.basename(process.cwd());
+      logger.info(`Validating current theme: ${themeToValidate}`);
+    } else {
+      logger.error(
+        "Not in a theme directory and no --theme specified. Run from theme root or use --theme flag."
+      );
+      process.exit(1);
+    }
+  }
+  const themePath = path.join(getThemesDir(), themeToValidate);
+  logger.startSpinner("Running validation checks...");
+  const manifestPath = path.join(themePath, "manifest.ts");
+  if (!fs.existsSync(manifestPath)) {
+    issues.push({
+      type: "error",
+      file: "manifest.ts",
+      message: "Manifest file not found"
+    });
+  } else {
+    const manifestContent = fs.readFileSync(manifestPath, "utf-8");
+    if (!manifestContent.includes("export const") && !manifestContent.includes("export default") && !manifestContent.includes("export interface")) {
+      issues.push({
+        type: "error",
+        file: "manifest.ts",
+        message: "Must have at least one export"
+      });
+    }
+  }
+  const configPath = path.join(themePath, "theme.config.ts");
+  if (!fs.existsSync(configPath)) {
+    issues.push({
+      type: "warning",
+      file: "theme.config.ts",
+      message: "Theme config file not found (recommended)"
+    });
+  }
+  const indexPath = path.join(themePath, "index.ts");
+  if (!fs.existsSync(indexPath)) {
+    issues.push({
+      type: "warning",
+      file: "index.ts",
+      message: "Index file not found (recommended)"
+    });
+  }
+  const sectionsDir = path.join(themePath, "sections");
+  if (!fs.existsSync(sectionsDir)) {
+    issues.push({
+      type: "warning",
+      file: "sections/",
+      message: "Sections directory not found"
+    });
+  } else {
+    const sections = fs.readdirSync(sectionsDir).filter(
+      (name) => fs.statSync(path.join(sectionsDir, name)).isDirectory()
+    );
+    for (const sectionName of sections) {
+      const sectionPath = path.join(sectionsDir, sectionName);
+      const schemaFile = path.join(sectionPath, `${sectionName}.schema.ts`);
+      const defaultTemplate = path.join(
+        sectionPath,
+        `${sectionName}-default.tsx`
+      );
+      const indexFile = path.join(sectionPath, "index.ts");
+      if (!fs.existsSync(schemaFile)) {
+        issues.push({
+          type: "error",
+          file: `sections/${sectionName}/${sectionName}.schema.ts`,
+          message: "Section schema file missing"
+        });
+      }
+      if (!fs.existsSync(indexFile)) {
+        issues.push({
+          type: "error",
+          file: `sections/${sectionName}/index.ts`,
+          message: "Section index file missing"
+        });
+      }
+      if (!fs.existsSync(defaultTemplate)) {
+        issues.push({
+          type: "warning",
+          file: `sections/${sectionName}/${sectionName}-default.tsx`,
+          message: "Default template not found (recommended)"
+        });
+      }
+    }
+  }
+  const blocksDir = path.join(themePath, "blocks");
+  if (fs.existsSync(blocksDir)) {
+    const blocks = fs.readdirSync(blocksDir).filter((name) => fs.statSync(path.join(blocksDir, name)).isDirectory());
+    for (const blockName of blocks) {
+      const blockPath = path.join(blocksDir, blockName);
+      const schemaFile = path.join(blockPath, `${blockName}.schema.ts`);
+      const componentFile = path.join(blockPath, `${blockName}.tsx`);
+      const indexFile = path.join(blockPath, "index.ts");
+      if (!fs.existsSync(schemaFile)) {
+        issues.push({
+          type: "error",
+          file: `blocks/${blockName}/${blockName}.schema.ts`,
+          message: "Block schema file missing"
+        });
+      }
+      if (!fs.existsSync(componentFile)) {
+        issues.push({
+          type: "error",
+          file: `blocks/${blockName}/${blockName}.tsx`,
+          message: "Block component file missing"
+        });
+      }
+      if (!fs.existsSync(indexFile)) {
+        issues.push({
+          type: "error",
+          file: `blocks/${blockName}/index.ts`,
+          message: "Block index file missing"
+        });
+      }
+    }
+  }
+  logger.stopSpinner(true, "Validation complete");
+  const errors = issues.filter((i) => i.type === "error");
+  const warnings = issues.filter((i) => i.type === "warning");
+  logger.newLine();
+  if (errors.length === 0 && warnings.length === 0) {
+    logger.success("\u2713 Theme is valid!");
+    logger.newLine();
+    logger.info(`Theme: ${themeToValidate}`);
+    logger.log("  No issues found");
+  } else {
+    if (errors.length > 0) {
+      logger.error(`\u2717 Found ${errors.length} error(s):`);
+      logger.newLine();
+      errors.forEach((issue) => {
+        logger.log(`  ${issue.file}`);
+        logger.log(`    ${issue.message}`);
+      });
+      logger.newLine();
+    }
+    if (warnings.length > 0) {
+      logger.warning(`\u26A0 Found ${warnings.length} warning(s):`);
+      logger.newLine();
+      warnings.forEach((issue) => {
+        logger.log(`  ${issue.file}`);
+        logger.log(`    ${issue.message}`);
+      });
+      logger.newLine();
+    }
+    if (errors.length > 0) {
+      logger.error("Validation failed. Please fix the errors above.");
+      process.exit(1);
+    } else {
+      logger.warning(
+        "Validation passed with warnings. Consider addressing them."
+      );
+    }
+  }
+}
+async function buildCommand(options) {
+  logger.header("Build Theme");
+  let themePath;
+  let themeName;
+  if (options.theme) {
+    themeName = options.theme;
+    try {
+      const workspaceThemePath = path.join(getThemesDir(), themeName);
+      if (fs.existsSync(workspaceThemePath)) {
+        themePath = workspaceThemePath;
+      } else {
+        themePath = path.join(process.cwd(), themeName);
+      }
+    } catch (e) {
+      themePath = path.join(process.cwd(), themeName);
+    }
+    if (!fs.existsSync(themePath)) {
+      logger.error(`Theme "${themeName}" not found.`);
+      process.exit(1);
+    }
+  } else {
+    const manifestPath = path.join(process.cwd(), "manifest.ts");
+    if (fs.existsSync(manifestPath)) {
+      themePath = process.cwd();
+      themeName = path.basename(themePath);
+      logger.info(`Building current theme: ${themeName}`);
+    } else {
+      logger.error(
+        "Not in a theme directory and no --theme specified. Run from theme root or use --theme flag."
+      );
+      process.exit(1);
+    }
+  }
+  const packageJsonPath = path.join(themePath, "package.json");
+  const hasPkgJson = fs.existsSync(packageJsonPath);
+  if (!hasPkgJson) {
+    logger.warning(
+      "No package.json found in theme. Skipping build (themes in monorepo are built via turbo)."
+    );
+    logger.newLine();
+    logger.info("To build all packages, run:");
+    logger.log("  pnpm turbo build");
+    logger.newLine();
+    logger.info("To build specific theme components:");
+    logger.log("  pnpm turbo build --filter=./src/themes/*");
+    return;
+  }
+  logger.newLine();
+  logger.section("Build Steps");
+  logger.startSpinner("Running type check...");
+  const typeCheckSuccess = await runCommand("pnpm", ["type-check"], themePath);
+  if (!typeCheckSuccess) {
+    logger.stopSpinner(false, "Type check failed");
+    logger.error("Fix type errors before building.");
+    process.exit(1);
+  }
+  logger.stopSpinner(true, "Type check passed");
+  logger.startSpinner("Running linter...");
+  const lintSuccess = await runCommand("pnpm", ["lint"], themePath);
+  if (!lintSuccess) {
+    logger.stopSpinner(false, "Lint failed");
+    logger.error("Fix lint errors before building.");
+    process.exit(1);
+  }
+  logger.stopSpinner(true, "Lint passed");
+  const buildArgs = options.watch ? ["build", "--watch"] : ["build"];
+  logger.startSpinner(
+    options.watch ? "Building (watch mode)..." : "Building..."
+  );
+  const buildSuccess = await runCommand("pnpm", buildArgs, themePath);
+  if (!buildSuccess && !options.watch) {
+    logger.stopSpinner(false, "Build failed");
+    process.exit(1);
+  }
+  if (!options.watch) {
+    logger.stopSpinner(true, "Build complete");
+    logger.newLine();
+    logger.success("\u2713 Theme built successfully!");
+    logger.newLine();
+    logger.info(`Theme: ${themeName}`);
+    const distPath = path.join(themePath, "dist");
+    if (fs.existsSync(distPath)) {
+      logger.log(`Output: ${path.relative(process.cwd(), distPath)}`);
+      const files = fs.readdirSync(distPath);
+      logger.log(`Files: ${files.length}`);
+    }
+  }
+}
+function runCommand(command, args, cwd) {
+  return new Promise((resolve) => {
+    const proc = spawn(command, args, {
+      cwd,
+      stdio: "pipe",
+      shell: true
+    });
+    let hasError = false;
+    proc.stderr.on("data", (data) => {
+      const message = data.toString();
+      if (message.includes("error") || message.includes("Error") || message.includes("ERROR")) {
+        hasError = true;
+      }
+    });
+    proc.on("close", (code) => {
+      resolve(code === 0 && !hasError);
+    });
+    proc.on("error", () => {
+      resolve(false);
+    });
+  });
+}
+async function packageCommand(options) {
+  logger.header("Package Theme");
+  ensureOneXProject();
+  let themePath;
+  let themeName;
+  if (options.theme) {
+    themeName = options.theme;
+    themePath = path.join(getThemesDir(), themeName);
+    if (!fs.existsSync(themePath)) {
+      logger.error(`Theme "${themeName}" not found.`);
+      process.exit(1);
+    }
+  } else {
+    const manifestPath = path.join(process.cwd(), "manifest.ts");
+    if (fs.existsSync(manifestPath)) {
+      themePath = process.cwd();
+      themeName = path.basename(themePath);
+      logger.info(`Packaging current theme: ${themeName}`);
+    } else {
+      logger.error(
+        "Not in a theme directory and no --theme specified. Run from theme root or use --theme flag."
+      );
+      process.exit(1);
+    }
+  }
+  const packageJsonPath = path.join(themePath, "package.json");
+  let version = "1.0.0";
+  if (fs.existsSync(packageJsonPath)) {
+    const packageJson = await fs.readJson(packageJsonPath);
+    version = packageJson.version || "1.0.0";
+  }
+  logger.newLine();
+  logger.info(`Theme: ${themeName}`);
+  logger.info(`Version: ${version}`);
+  logger.newLine();
+  const compiledThemePath = path.join(
+    process.cwd(),
+    "apps",
+    "api-server",
+    "compiled-themes",
+    `${themeName}@${version}`
+  );
+  if (!options.skipBuild) {
+    logger.section("Step 1: Compile Theme");
+    logger.startSpinner("Compiling theme with esbuild...");
+    const compileArgs = ["tsx", "scripts/compile-theme.ts", themeName];
+    if (options.minify) {
+      compileArgs.push("--minify");
+    }
+    const compileSuccess = await runCommand2(
+      compileArgs[0],
+      compileArgs.slice(1)
+    );
+    if (!compileSuccess) {
+      logger.stopSpinner(false, "Compilation failed");
+      logger.error("Fix compilation errors before packaging.");
+      process.exit(1);
+    }
+    logger.stopSpinner(true, "Theme compiled");
+  } else {
+    logger.info("Skipping build (--skip-build flag)");
+  }
+  if (!fs.existsSync(compiledThemePath)) {
+    logger.error(`Compiled theme not found at: ${compiledThemePath}`);
+    logger.info("Run without --skip-build to compile first.");
+    process.exit(1);
+  }
+  logger.newLine();
+  logger.section("Step 2: Create Package");
+  const packageName = options.name || `${themeName}-${version}`;
+  const outputDir = options.output || path.join(process.cwd(), "dist");
+  const outputPath = path.join(outputDir, `${packageName}.zip`);
+  await fs.ensureDir(outputDir);
+  logger.startSpinner("Creating zip archive...");
+  try {
+    await createZipArchive(compiledThemePath, outputPath);
+    logger.stopSpinner(true, "Package created");
+    const stats = await fs.stat(outputPath);
+    const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+    logger.newLine();
+    logger.success("\u2713 Theme packaged successfully!");
+    logger.newLine();
+    logger.info(`Package: ${packageName}.zip`);
+    logger.log(`Size: ${sizeMB} MB`);
+    logger.log(`Location: ${path.relative(process.cwd(), outputPath)}`);
+    logger.newLine();
+    logger.section("Next steps:");
+    logger.log(
+      `  onex deploy --package ${path.relative(process.cwd(), outputPath)}`
+    );
+  } catch (error) {
+    logger.stopSpinner(false, "Failed to create package");
+    logger.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    process.exit(1);
+  }
+}
+function runCommand2(command, args) {
+  return new Promise((resolve) => {
+    const proc = spawn(command, args, {
+      cwd: process.cwd(),
+      stdio: "pipe",
+      shell: true
+    });
+    let hasError = false;
+    proc.stderr.on("data", (data) => {
+      const message = data.toString();
+      if (message.includes("error") || message.includes("Error") || message.includes("ERROR")) {
+        hasError = true;
+      }
+    });
+    proc.on("close", (code) => {
+      resolve(code === 0 && !hasError);
+    });
+    proc.on("error", () => {
+      resolve(false);
+    });
+  });
+}
+async function createZipArchive(compiledThemePath, outputPath) {
+  return new Promise((resolve, reject) => {
+    const output = fs.createWriteStream(outputPath);
+    const archive = archiver("zip", {
+      zlib: { level: 9 }
+      // Maximum compression
+    });
+    output.on("close", () => {
+      resolve();
+    });
+    archive.on("error", (err) => {
+      reject(err);
+    });
+    archive.pipe(output);
+    archive.directory(compiledThemePath, false);
+    archive.finalize();
+  });
+}
+async function deployCommand(options) {
+  logger.header("Deploy Theme");
+  ensureOneXProject();
+  let packagePath;
+  if (options.package) {
+    packagePath = path.resolve(options.package);
+  } else if (options.theme) {
+    const distDir = path.join(process.cwd(), "dist");
+    if (!fs.existsSync(distDir)) {
+      logger.error("No dist/ directory found. Run 'onex package' first.");
+      process.exit(1);
+    }
+    const files = fs.readdirSync(distDir);
+    const packageFiles = files.filter(
+      (f) => f.startsWith(options.theme) && f.endsWith(".zip")
+    );
+    if (packageFiles.length === 0) {
+      logger.error(`No package found for theme "${options.theme}".`);
+      logger.info("Run: onex package --theme " + options.theme);
+      process.exit(1);
+    }
+    packageFiles.sort().reverse();
+    packagePath = path.join(distDir, packageFiles[0]);
+  } else {
+    logger.error("Either --package or --theme must be specified.");
+    logger.info("Examples:");
+    logger.log("  onex deploy --package dist/tinan-1.0.0.zip");
+    logger.log("  onex deploy --theme tinan");
+    process.exit(1);
+  }
+  if (!fs.existsSync(packagePath)) {
+    logger.error(`Package not found: ${packagePath}`);
+    process.exit(1);
+  }
+  const stats = await fs.stat(packagePath);
+  const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+  const fileName = path.basename(packagePath);
+  logger.newLine();
+  logger.info(`Package: ${fileName}`);
+  logger.log(`Size: ${sizeMB} MB`);
+  logger.log(`Path: ${path.relative(process.cwd(), packagePath)}`);
+  logger.newLine();
+  const apiUrl = options.apiUrl || process.env.ONEX_API_URL || "http://localhost:3001";
+  const uploadEndpoint = `${apiUrl}/api/themes/upload`;
+  logger.section("Uploading to API Server");
+  logger.info(`Endpoint: ${uploadEndpoint}`);
+  logger.newLine();
+  logger.startSpinner("Uploading theme package...");
+  try {
+    const formData = new FormData();
+    formData.append("theme", fs.createReadStream(packagePath), {
+      filename: fileName,
+      contentType: "application/zip"
+    });
+    if (options.apiKey) {
+      formData.append("apiKey", options.apiKey);
+    }
+    if (options.environment) {
+      formData.append("environment", options.environment);
+    }
+    const response = await fetch(uploadEndpoint, {
+      method: "POST",
+      body: formData,
+      headers: formData.getHeaders()
+    });
+    const result = await response.json();
+    if (!response.ok) {
+      logger.stopSpinner(false, "Upload failed");
+      logger.error(
+        `Server returned ${response.status}: ${response.statusText}`
+      );
+      if (result.error) {
+        logger.log(`Error: ${result.error}`);
+      }
+      process.exit(1);
+    }
+    logger.stopSpinner(true, "Upload complete");
+    logger.newLine();
+    logger.success("\u2713 Theme deployed successfully!");
+    logger.newLine();
+    if (result.themeId) {
+      logger.info(`Theme ID: ${result.themeId}`);
+    }
+    if (result.version) {
+      logger.info(`Version: ${result.version}`);
+    }
+    if (result.url) {
+      logger.info(`Preview URL: ${result.url}`);
+    }
+    logger.newLine();
+    logger.log("Theme is now available on the API server!");
+  } catch (error) {
+    logger.stopSpinner(false, "Upload failed");
+    logger.error(
+      `Failed to upload: ${error instanceof Error ? error.message : String(error)}`
+    );
+    logger.newLine();
+    logger.info("Make sure the API server is running:");
+    logger.log("  cd apps/api-server && pnpm dev");
+    process.exit(1);
+  }
+}
+function getS3Client() {
+  const adapterMode = (process.env.ADAPTER_MODE || "aws").trim().toLowerCase();
+  if (adapterMode === "vps") {
+    const endpoint = process.env.MINIO_ENDPOINT || "localhost:9000";
+    const secure = process.env.MINIO_SECURE === "true";
+    const endpointUrl = endpoint.startsWith("http") ? endpoint : `${secure ? "https" : "http"}://${endpoint}`;
+    return new S3Client({
+      endpoint: endpointUrl,
+      region: "us-east-1",
+      // MinIO doesn't use real regions
+      credentials: {
+        accessKeyId: process.env.MINIO_ACCESS_KEY || "minioadmin",
+        secretAccessKey: process.env.MINIO_SECRET_KEY || "minioadmin"
+      },
+      forcePathStyle: true
+      // Required for MinIO
+    });
+  }
+  if (adapterMode === "local") {
+    return new S3Client({
+      endpoint: "http://localhost:4569",
+      region: "ap-southeast-1",
+      credentials: {
+        accessKeyId: "S3RVER",
+        secretAccessKey: "S3RVER"
+      },
+      forcePathStyle: true
+    });
+  }
+  return new S3Client({
+    region: process.env.AWS_REGION || "ap-southeast-1"
+  });
+}
+function getBucketName(env) {
+  if (process.env.BUCKET_NAME) {
+    return process.env.BUCKET_NAME;
+  }
+  const environment = env || process.env.ENVIRONMENT || "staging";
+  return environment === "production" ? "onex-themes-prod" : "onex-themes-staging";
+}
+async function findCompiledThemeDir(themeId, version) {
+  const searchPaths = [
+    path.resolve(process.cwd(), "dist"),
+    path.resolve(
+      process.cwd(),
+      `../../apps/api-server/compiled-themes/${themeId}@${version}`
+    ),
+    path.resolve(
+      process.cwd(),
+      `../api-server/compiled-themes/${themeId}@${version}`
+    )
+  ];
+  for (const dir of searchPaths) {
+    if (await fs.pathExists(dir)) {
+      const manifestPath = path.join(dir, "manifest.json");
+      if (await fs.pathExists(manifestPath)) {
+        return dir;
+      }
+    }
+  }
+  return null;
+}
+async function readManifest() {
+  var _a;
+  const manifestTsPath = path.resolve(process.cwd(), "manifest.ts");
+  if (await fs.pathExists(manifestTsPath)) {
+    try {
+      const module = await import(manifestTsPath);
+      return module.default || module;
+    } catch (error) {
+      logger.warning("Failed to import manifest.ts, trying package.json");
+    }
+  }
+  const packageJsonPath = path.resolve(process.cwd(), "package.json");
+  if (await fs.pathExists(packageJsonPath)) {
+    const pkg = await fs.readJson(packageJsonPath);
+    return {
+      themeId: ((_a = pkg.name) == null ? void 0 : _a.replace("@onex-themes/", "")) || "unknown",
+      version: pkg.version || "1.0.0"
+    };
+  }
+  throw new Error(
+    "No manifest.ts or package.json found. Are you in a theme directory?"
+  );
+}
+function getContentType(filename) {
+  const ext = path.extname(filename).toLowerCase();
+  const types = {
+    ".js": "application/javascript",
+    ".mjs": "application/javascript",
+    ".json": "application/json",
+    ".css": "text/css",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".svg": "image/svg+xml",
+    ".woff2": "font/woff2",
+    ".woff": "font/woff",
+    ".ttf": "font/ttf",
+    ".ts": "text/plain"
+  };
+  return types[ext] || "application/octet-stream";
+}
+async function uploadFile(s3Client, bucket, themeId, version, baseDir, file) {
+  const filePath = path.join(baseDir, file);
+  const content = await fs.readFile(filePath);
+  const s3Key = `themes/${themeId}/${version}/${file}`;
+  await s3Client.send(
+    new PutObjectCommand({
+      Bucket: bucket,
+      Key: s3Key,
+      Body: content,
+      ContentType: getContentType(file)
+    })
+  );
+}
+async function updateLatestPointer(s3Client, bucket, themeId, version) {
+  const latestData = {
+    version,
+    uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await s3Client.send(
+    new PutObjectCommand({
+      Bucket: bucket,
+      Key: `themes/${themeId}/latest.json`,
+      Body: JSON.stringify(latestData, null, 2),
+      ContentType: "application/json"
+    })
+  );
+}
+async function uploadCommand(options) {
+  logger.header("Upload Theme to S3");
+  ensureOneXProject();
+  const spinner = ora("Preparing theme upload...").start();
+  try {
+    const manifest = await readManifest();
+    const themeId = manifest.themeId;
+    const version = options.version || manifest.version || "1.0.0";
+    spinner.text = `Found theme: ${themeId}@${version}`;
+    const bucket = options.bucket || getBucketName(options.environment);
+    const s3Client = getS3Client();
+    const compiledDir = await findCompiledThemeDir(themeId, version);
+    if (!compiledDir) {
+      spinner.fail(
+        chalk4.red(
+          `Compiled theme not found for ${themeId}@${version}. Run 'onex build' first.`
+        )
+      );
+      logger.info(
+        chalk4.gray(
+          `Expected locations:
+  - ./dist/
+  - ../../apps/api-server/compiled-themes/${themeId}@${version}/`
+        )
+      );
+      process.exit(1);
+    }
+    spinner.succeed(`Found compiled theme at: ${compiledDir}`);
+    spinner.start(`Scanning files...`);
+    const files = await glob("**/*", {
+      cwd: compiledDir,
+      nodir: true,
+      dot: true
+    });
+    if (files.length === 0) {
+      spinner.fail(chalk4.red("No files found in compiled theme directory"));
+      process.exit(1);
+    }
+    spinner.succeed(`Found ${files.length} files to upload`);
+    if (options.dryRun) {
+      spinner.info(chalk4.yellow("Dry run mode - no files will be uploaded"));
+      console.log(chalk4.gray("\nFiles to upload:"));
+      const displayFiles = files.slice(0, 10);
+      displayFiles.forEach((file) => console.log(chalk4.gray(`  - ${file}`)));
+      if (files.length > 10) {
+        console.log(chalk4.gray(`  ... and ${files.length - 10} more files
+`));
+      }
+      console.log(chalk4.cyan(`
+S3 bucket: ${bucket}`));
+      console.log(
+        chalk4.cyan(`S3 path: s3://${bucket}/themes/${themeId}/${version}/
+`)
+      );
+      return;
+    }
+    spinner.start(`Uploading to S3: ${bucket}...`);
+    let uploaded = 0;
+    const total = files.length;
+    const batchSize = 10;
+    for (let i = 0; i < files.length; i += batchSize) {
+      const batch = files.slice(i, i + batchSize);
+      await Promise.all(
+        batch.map(async (file) => {
+          await uploadFile(
+            s3Client,
+            bucket,
+            themeId,
+            version,
+            compiledDir,
+            file
+          );
+          uploaded++;
+          spinner.text = `Uploading... ${uploaded}/${total} files (${Math.round(uploaded / total * 100)}%)`;
+        })
+      );
+    }
+    spinner.succeed(`Uploaded ${total} files to S3`);
+    spinner.start("Updating latest.json pointer...");
+    await updateLatestPointer(s3Client, bucket, themeId, version);
+    spinner.succeed("Updated latest.json pointer");
+    console.log();
+    logger.success(chalk4.green.bold("\u2705 Theme uploaded successfully!"));
+    console.log();
+    console.log(
+      chalk4.cyan("   Theme:   ") + chalk4.white(`${themeId}@${version}`)
+    );
+    console.log(chalk4.cyan("   Bucket:  ") + chalk4.white(bucket));
+    console.log(chalk4.cyan("   Files:   ") + chalk4.white(total));
+    console.log(
+      chalk4.cyan("   Path:    ") + chalk4.gray(`s3://${bucket}/themes/${themeId}/${version}/`)
+    );
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk4.red(`Upload failed: ${error.message}`));
+    logger.error(error.stack || error.message);
+    process.exit(1);
+  }
+}
+function getS3Client2() {
+  const adapterMode = (process.env.ADAPTER_MODE || "aws").trim().toLowerCase();
+  if (adapterMode === "vps") {
+    const endpoint = process.env.MINIO_ENDPOINT || "localhost:9000";
+    const secure = process.env.MINIO_SECURE === "true";
+    const endpointUrl = endpoint.startsWith("http") ? endpoint : `${secure ? "https" : "http"}://${endpoint}`;
+    return new S3Client({
+      endpoint: endpointUrl,
+      region: "us-east-1",
+      credentials: {
+        accessKeyId: process.env.MINIO_ACCESS_KEY || "minioadmin",
+        secretAccessKey: process.env.MINIO_SECRET_KEY || "minioadmin"
+      },
+      forcePathStyle: true
+    });
+  }
+  if (adapterMode === "local") {
+    return new S3Client({
+      endpoint: "http://localhost:4569",
+      region: "ap-southeast-1",
+      credentials: {
+        accessKeyId: "S3RVER",
+        secretAccessKey: "S3RVER"
+      },
+      forcePathStyle: true
+    });
+  }
+  return new S3Client({
+    region: process.env.AWS_REGION || "ap-southeast-1"
+  });
+}
+function getBucketName2(env) {
+  if (process.env.BUCKET_NAME) {
+    return process.env.BUCKET_NAME;
+  }
+  const environment = env || process.env.ENVIRONMENT || "staging";
+  return environment === "production" ? "onex-themes-prod" : "onex-themes-staging";
+}
+async function streamToString(stream) {
+  const chunks = [];
+  try {
+    for (var iter = __forAwait(stream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+      const chunk = temp.value;
+      chunks.push(Buffer.from(chunk));
+    }
+  } catch (temp) {
+    error = [temp];
+  } finally {
+    try {
+      more && (temp = iter.return) && await temp.call(iter);
+    } finally {
+      if (error)
+        throw error[0];
+    }
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function streamToBuffer(stream) {
+  const chunks = [];
+  try {
+    for (var iter = __forAwait(stream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+      const chunk = temp.value;
+      chunks.push(Buffer.from(chunk));
+    }
+  } catch (temp) {
+    error = [temp];
+  } finally {
+    try {
+      more && (temp = iter.return) && await temp.call(iter);
+    } finally {
+      if (error)
+        throw error[0];
+    }
+  }
+  return Buffer.concat(chunks);
+}
+async function resolveLatestVersion(s3Client, bucket, themeId) {
+  try {
+    const response = await s3Client.send(
+      new GetObjectCommand({
+        Bucket: bucket,
+        Key: `themes/${themeId}/latest.json`
+      })
+    );
+    const body = await streamToString(response.Body);
+    const data = JSON.parse(body);
+    return data.version;
+  } catch (error) {
+    throw new Error(
+      `Failed to resolve latest version for theme "${themeId}": ${error.message}`
+    );
+  }
+}
+async function downloadManifest(s3Client, bucket, themeId, version) {
+  try {
+    const response = await s3Client.send(
+      new GetObjectCommand({
+        Bucket: bucket,
+        Key: `themes/${themeId}/${version}/manifest.json`
+      })
+    );
+    const body = await streamToString(response.Body);
+    return JSON.parse(body);
+  } catch (error) {
+    throw new Error(
+      `Failed to download manifest for ${themeId}@${version}: ${error.message}
+The theme may not exist in S3 bucket "${bucket}".`
+    );
+  }
+}
+async function downloadFile(s3Client, bucket, themeId, version, file, outputDir) {
+  const s3Key = `themes/${themeId}/${version}/${file}`;
+  const localPath = path.join(outputDir, file);
+  await fs.ensureDir(path.dirname(localPath));
+  try {
+    const response = await s3Client.send(
+      new GetObjectCommand({
+        Bucket: bucket,
+        Key: s3Key
+      })
+    );
+    const content = await streamToBuffer(response.Body);
+    await fs.writeFile(localPath, content);
+  } catch (error) {
+    throw new Error(`Failed to download ${file}: ${error.message}`);
+  }
+}
+function collectFilesToDownload(manifest) {
+  const files = ["manifest.json"];
+  if (manifest.output) {
+    if (manifest.output.entry) {
+      files.push(manifest.output.entry);
+    }
+    if (manifest.output.chunks) {
+      files.push(...manifest.output.chunks);
+    }
+    if (manifest.output.assets) {
+      files.push(...manifest.output.assets);
+    }
+  }
+  return files;
+}
+async function createCompatibilityFiles(outputDir) {
+  const sectionsRegistryPath = path.join(outputDir, "sections-registry.js");
+  const content = `// Re-export all sections from bundle-entry
+// This file exists to maintain compatibility with the import path
+export * from './bundle-entry.js';
+`;
+  await fs.writeFile(sectionsRegistryPath, content, "utf-8");
+}
+function showDownloadFailureHelp(themeId, bucket) {
+  console.log();
+  logger.error(chalk4.red.bold("\u274C Theme download failed"));
+  console.log();
+  console.log(chalk4.yellow("Possible reasons:"));
+  console.log(chalk4.gray("  1. Theme not uploaded to S3 yet"));
+  console.log(chalk4.gray("  2. AWS credentials not configured correctly"));
+  console.log(chalk4.gray("  3. Bucket name or region is incorrect"));
+  console.log(chalk4.gray("  4. Theme files are incomplete or corrupted"));
+  console.log();
+  console.log(chalk4.cyan.bold("To fix this:"));
+  console.log();
+  console.log(chalk4.white("1. Compile and upload the theme:"));
+  console.log(chalk4.gray(`   cd themes/${themeId}`));
+  console.log(chalk4.gray("   pnpm build"));
+  console.log(chalk4.gray("   pnpm upload"));
+  console.log();
+  console.log(chalk4.white("2. Verify AWS credentials are set:"));
+  console.log(
+    chalk4.gray("   - Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY")
+  );
+  console.log(chalk4.gray("   - Or use AWS_PROFILE=your-profile"));
+  console.log(chalk4.gray("   - Set AWS_REGION (e.g., ap-southeast-1)"));
+  console.log();
+  console.log(chalk4.white("3. Check bucket configuration:"));
+  console.log(chalk4.gray(`   Current bucket: ${bucket}`));
+  console.log(
+    chalk4.gray("   Set BUCKET_NAME environment variable if different")
+  );
+  console.log();
+  console.log(chalk4.white("4. Verify theme exists in S3:"));
+  console.log(chalk4.gray(`   aws s3 ls s3://${bucket}/themes/${themeId}/`));
+  console.log();
+}
+async function downloadCommand(options) {
+  logger.header("Download Theme from S3");
+  const spinner = ora("Initializing download...").start();
+  try {
+    const themeId = options.themeId || process.env.NEXT_PUBLIC_THEME_ID || process.env.THEME_ID;
+    const version = options.version || process.env.THEME_VERSION || "latest";
+    const bucket = options.bucket || getBucketName2(options.environment);
+    const outputDir = options.output || "./active-theme";
+    if (!themeId) {
+      spinner.fail(
+        chalk4.red(
+          "Theme ID not specified. Use --theme-id or set NEXT_PUBLIC_THEME_ID environment variable."
+        )
+      );
+      process.exit(1);
+    }
+    spinner.text = `Downloading ${themeId}@${version} from ${bucket}...`;
+    const s3Client = getS3Client2();
+    let resolvedVersion = version;
+    if (version === "latest") {
+      spinner.text = "Resolving latest version...";
+      resolvedVersion = await resolveLatestVersion(s3Client, bucket, themeId);
+      spinner.succeed(
+        `Resolved latest version: ${chalk4.cyan(resolvedVersion)}`
+      );
+      spinner.start("Downloading manifest...");
+    }
+    const manifest = await downloadManifest(
+      s3Client,
+      bucket,
+      themeId,
+      resolvedVersion
+    );
+    spinner.succeed("Downloaded manifest");
+    spinner.start("Preparing output directory...");
+    await fs.remove(outputDir);
+    await fs.ensureDir(outputDir);
+    spinner.succeed("Output directory ready");
+    spinner.start("Downloading theme files...");
+    const files = collectFilesToDownload(manifest);
+    let downloaded = 0;
+    const total = files.length;
+    const batchSize = 10;
+    for (let i = 0; i < files.length; i += batchSize) {
+      const batch = files.slice(i, i + batchSize);
+      await Promise.all(
+        batch.map(async (file) => {
+          await downloadFile(
+            s3Client,
+            bucket,
+            themeId,
+            resolvedVersion,
+            file,
+            outputDir
+          );
+          downloaded++;
+          spinner.text = `Downloading... ${downloaded}/${total} files (${Math.round(downloaded / total * 100)}%)`;
+        })
+      );
+    }
+    spinner.succeed(`Downloaded ${total} files`);
+    await createCompatibilityFiles(outputDir);
+    console.log();
+    logger.success(chalk4.green.bold("\u2705 Theme downloaded successfully!"));
+    console.log();
+    console.log(
+      chalk4.cyan("   Theme:   ") + chalk4.white(`${themeId}@${resolvedVersion}`)
+    );
+    console.log(chalk4.cyan("   Bucket:  ") + chalk4.white(bucket));
+    console.log(chalk4.cyan("   Output:  ") + chalk4.white(outputDir));
+    console.log(chalk4.cyan("   Files:   ") + chalk4.white(total));
+    console.log(
+      chalk4.cyan("   Sections:") + chalk4.white(` ${manifest.counts.sections}`)
+    );
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk4.red("Download failed"));
+    logger.error(error.message);
+    const themeId = options.themeId || process.env.NEXT_PUBLIC_THEME_ID || "unknown";
+    const bucket = options.bucket || getBucketName2(options.environment);
+    showDownloadFailureHelp(themeId, bucket);
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("onex").description("CLI tool for OneX theme development").version("0.1.0");
+program.command("init").description("Create a new OneX theme project").argument("[project-name]", "Name of the project").option(
+  "-t, --template <template>",
+  "Template to use (default, minimal)",
+  "default"
+).option("--no-install", "Skip installing dependencies").option("--git", "Initialize git repository").option("-y, --yes", "Skip prompts and use defaults").action(initCommand);
+program.command("create:section").alias("cs").description("Create a new section").argument("<name>", "Name of the section (e.g., hero, features)").option("-t, --theme <theme>", "Theme to create section in").option(
+  "-c, --category <category>",
+  "Section category (headers, content, footers)"
+).option(
+  "--template <template>",
+  "Initial template variant (default, minimal)"
+).action(createSectionCommand);
+program.command("create:block").alias("cb").description("Create a new block").argument(
+  "<name>",
+  "Name of the block (e.g., product-card, testimonial-item)"
+).option("-t, --theme <theme>", "Theme to create block in (optional)").action(createBlockCommand);
+program.command("create:component").alias("cc").description("Create a new component").argument("<name>", "Name of the component (e.g., button, badge)").option("-t, --type <type>", "Component type (ui, layout, form)").action(createComponentCommand);
+program.command("list").description("List available themes, sections, blocks, and components").option("-s, --sections", "List sections only").option("-b, --blocks", "List blocks only").option("-c, --components", "List components only").option("-t, --theme <theme>", "Filter by theme").action(listCommand);
+program.command("validate").description("Validate theme structure and files").option("-t, --theme <theme>", "Theme to validate").option("-f, --fix", "Auto-fix issues if possible (not implemented yet)").action(validateCommand);
+program.command("build").description("Build theme for production").option("-t, --theme <theme>", "Theme to build").option("-p, --production", "Production build with optimizations").option("-w, --watch", "Watch mode for development").action(buildCommand);
+program.command("package").description("Compile and package theme as distributable zip file").option("-t, --theme <theme>", "Theme to package").option("-o, --output <dir>", "Output directory for package").option("-n, --name <name>", "Custom package name").option("-m, --minify", "Minify compiled output").option("--skip-build", "Skip compilation step (use existing compiled theme)").action(packageCommand);
+program.command("deploy").description("Upload theme package to API server").option("-t, --theme <theme>", "Theme to deploy (finds latest package)").option("-p, --package <file>", "Specific package file to upload").option("--api-url <url>", "API server URL (default: http://localhost:3001)").option("-k, --api-key <key>", "API key for authentication").option(
+  "-e, --environment <env>",
+  "Environment (production, staging, development)"
+).action(deployCommand);
+program.command("upload").description("Upload compiled theme to S3 bucket").option("-t, --theme <theme>", "Theme to upload").option("-b, --bucket <name>", "S3 bucket name").option("-v, --version <version>", "Theme version").option(
+  "-e, --environment <env>",
+  "Environment (staging|production)",
+  "staging"
+).option("--dry-run", "Show what would be uploaded without uploading").action(uploadCommand);
+program.command("download").description("Download theme from S3 bucket").option("-t, --theme-id <id>", "Theme ID to download").option(
+  "-v, --version <version>",
+  "Theme version (default: latest)",
+  "latest"
+).option("-b, --bucket <name>", "S3 bucket name").option(
+  "-e, --environment <env>",
+  "Environment (staging|production)",
+  "staging"
+).option("-o, --output <dir>", "Output directory", "./active-theme").action(downloadCommand);
+program.configureOutput({
+  writeErr: (str) => process.stderr.write(chalk4.red(str))
+});
+program.parse();
+//# sourceMappingURL=cli.mjs.map
+//# sourceMappingURL=cli.mjs.map