@onexapis/cli 1.0.0 → 1.0.1

package/dist/index.js

@@ -9,7 +9,9 @@ var ora = require('ora');
 var fs = require('fs-extra');
 var ejs = require('ejs');
 var clientS3 = require('@aws-sdk/client-s3');
-var glob = require('glob');
+var os = require('os');
+var archiver = require('archiver');
+var AdmZip = require('adm-zip');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -20,6 +22,9 @@ var chalk4__default = /*#__PURE__*/_interopDefault(chalk4);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var ejs__default = /*#__PURE__*/_interopDefault(ejs);
+var os__default = /*#__PURE__*/_interopDefault(os);
+var archiver__default = /*#__PURE__*/_interopDefault(archiver);
+var AdmZip__default = /*#__PURE__*/_interopDefault(AdmZip);
 
 var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
@@ -99,8 +104,8 @@ function validateThemeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name);
 }
 function pathExists(filePath) {
-  const fs7 = __require("fs-extra");
-  return fs7.existsSync(filePath);
+  const fs8 = __require("fs-extra");
+  return fs8.existsSync(filePath);
 }
 function validateCategory(category) {
   const validCategories = [
@@ -217,18 +222,19 @@ function getProjectRoot() {
   return process.cwd();
 }
 function getThemesDir() {
-  try {
-    return path__default.default.join(getProjectRoot(), "src/themes");
-  } catch (e) {
-    return path__default.default.join(getProjectRoot(), "themes");
+  const root = getProjectRoot();
+  const themesDir = path__default.default.join(root, "themes");
+  if (fs__default.default.existsSync(themesDir)) {
+    return themesDir;
   }
+  return path__default.default.join(root, "src/themes");
 }
 function getFeaturesDir() {
   return path__default.default.join(getProjectRoot(), "src/features");
 }
 function isOneXProject() {
   const root = getProjectRoot();
-  return fs__default.default.existsSync(path__default.default.join(root, "src/themes")) && fs__default.default.existsSync(path__default.default.join(root, "src/lib/registry"));
+  return fs__default.default.existsSync(path__default.default.join(root, "themes")) || fs__default.default.existsSync(path__default.default.join(root, "src/themes"));
 }
 function ensureOneXProject() {
   if (!isOneXProject()) {
@@ -245,12 +251,12 @@ function listThemes() {
   }
   return fs__default.default.readdirSync(themesDir).filter((name) => {
     const themePath = path__default.default.join(themesDir, name);
-    return fs__default.default.statSync(themePath).isDirectory() && fs__default.default.existsSync(path__default.default.join(themePath, "manifest.ts"));
+    return fs__default.default.statSync(themePath).isDirectory() && (fs__default.default.existsSync(path__default.default.join(themePath, "theme.config.ts")) || fs__default.default.existsSync(path__default.default.join(themePath, "bundle-entry.ts")) || fs__default.default.existsSync(path__default.default.join(themePath, "manifest.ts")));
   });
 }
 function themeExists(themeName) {
   const themePath = path__default.default.join(getThemesDir(), themeName);
-  return fs__default.default.existsSync(themePath) && fs__default.default.existsSync(path__default.default.join(themePath, "manifest.ts"));
+  return fs__default.default.existsSync(themePath) && (fs__default.default.existsSync(path__default.default.join(themePath, "theme.config.ts")) || fs__default.default.existsSync(path__default.default.join(themePath, "bundle-entry.ts")) || fs__default.default.existsSync(path__default.default.join(themePath, "manifest.ts")));
 }
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent || "";
@@ -444,7 +450,9 @@ Add your theme-specific blocks here.
     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/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");
@@ -1447,8 +1455,16 @@ async function listThemesInfo() {
   }
   logger.log("");
   for (const theme of themes) {
-    const manifestPath = path__default.default.join(getThemesDir(), theme, "manifest.ts");
-    const manifestContent = fs__default.default.readFileSync(manifestPath, "utf-8");
+    const themeDir = path__default.default.join(getThemesDir(), theme);
+    const candidates = ["theme.config.ts", "bundle-entry.ts", "manifest.ts"];
+    let manifestContent = "";
+    for (const candidate of candidates) {
+      const candidatePath = path__default.default.join(themeDir, candidate);
+      if (fs__default.default.existsSync(candidatePath)) {
+        manifestContent = fs__default.default.readFileSync(candidatePath, "utf-8");
+        break;
+      }
+    }
     const nameMatch = manifestContent.match(/name:\s*["'](.+)["']/);
     const versionMatch = manifestContent.match(/version:\s*["'](.+)["']/);
     const descMatch = manifestContent.match(/description:\s*["'](.+)["']/);
@@ -1581,13 +1597,11 @@ function getS3Client() {
     return new clientS3.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") {
@@ -1657,36 +1671,40 @@ async function readManifest() {
     "No manifest.ts or package.json found. Are you in a theme directory?"
   );
 }
-function getContentType(filename) {
-  const ext = path__default.default.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 createZipFromDir(sourceDir, outputPath, excludePatterns = []) {
+  return new Promise((resolve, reject) => {
+    const output = fs__default.default.createWriteStream(outputPath);
+    const archive = archiver__default.default("zip", { zlib: { level: 6 } });
+    output.on("close", () => resolve());
+    archive.on("error", (err) => reject(err));
+    archive.pipe(output);
+    archive.glob("**/*", {
+      cwd: sourceDir,
+      dot: true,
+      ignore: excludePatterns
+    });
+    archive.finalize();
+  });
 }
-async function uploadFile(s3Client, bucket, themeId, version, baseDir, file) {
-  const filePath = path__default.default.join(baseDir, file);
-  const content = await fs__default.default.readFile(filePath);
-  const s3Key = `themes/${themeId}/${version}/${file}`;
-  await s3Client.send(
-    new clientS3.PutObjectCommand({
-      Bucket: bucket,
-      Key: s3Key,
-      Body: content,
-      ContentType: getContentType(file)
-    })
-  );
+async function findSourceDir(themeId, explicitDir) {
+  if (explicitDir) {
+    if (await fs__default.default.pathExists(explicitDir)) return explicitDir;
+    return null;
+  }
+  const searchPaths = [
+    process.cwd(),
+    path__default.default.resolve(process.cwd(), `../../themes/${themeId}`),
+    path__default.default.resolve(process.cwd(), `../themes/${themeId}`)
+  ];
+  const markers = ["theme.config.ts", "bundle-entry.ts"];
+  for (const dir of searchPaths) {
+    for (const marker of markers) {
+      if (await fs__default.default.pathExists(path__default.default.join(dir, marker))) {
+        return dir;
+      }
+    }
+  }
+  return null;
 }
 async function updateLatestPointer(s3Client, bucket, themeId, version) {
   const latestData = {
@@ -1704,12 +1722,18 @@ async function updateLatestPointer(s3Client, bucket, themeId, version) {
 }
 async function uploadCommand(options) {
   logger.header("Upload Theme to S3");
-  ensureOneXProject();
   const spinner = ora__default.default("Preparing theme upload...").start();
   try {
-    const manifest = await readManifest();
-    const themeId = manifest.themeId;
-    const version = options.version || manifest.version || "1.0.0";
+    let themeId;
+    let version;
+    if (options.theme) {
+      themeId = options.theme;
+      version = options.version || "1.0.0";
+    } else {
+      const manifest = await readManifest();
+      themeId = manifest.themeId;
+      version = options.version || manifest.version || "1.0.0";
+    }
     spinner.text = `Found theme: ${themeId}@${version}`;
     const bucket = options.bucket || getBucketName(options.environment);
     const s3Client = getS3Client();
@@ -1730,67 +1754,113 @@ async function uploadCommand(options) {
       process.exit(1);
     }
     spinner.succeed(`Found compiled theme at: ${compiledDir}`);
-    spinner.start(`Scanning files...`);
-    const files = await glob.glob("**/*", {
-      cwd: compiledDir,
-      nodir: true,
-      dot: true
-    });
-    if (files.length === 0) {
-      spinner.fail(chalk4__default.default.red("No files found in compiled theme directory"));
-      process.exit(1);
-    }
-    spinner.succeed(`Found ${files.length} files to upload`);
+    spinner.start("Creating bundle.zip...");
+    const tmpDir = os__default.default.tmpdir();
+    const bundleZipPath = path__default.default.join(tmpDir, `${themeId}-${version}-bundle.zip`);
+    await createZipFromDir(compiledDir, bundleZipPath);
+    const bundleZipBuffer = await fs__default.default.readFile(bundleZipPath);
+    const bundleSizeMB = (bundleZipBuffer.length / 1024 / 1024).toFixed(2);
+    spinner.succeed(`Created bundle.zip (${bundleSizeMB} MB)`);
     if (options.dryRun) {
-      spinner.info(chalk4__default.default.yellow("Dry run mode - no files will be uploaded"));
-      console.log(chalk4__default.default.gray("\nFiles to upload:"));
-      const displayFiles = files.slice(0, 10);
-      displayFiles.forEach((file) => console.log(chalk4__default.default.gray(`  - ${file}`)));
-      if (files.length > 10) {
-        console.log(chalk4__default.default.gray(`  ... and ${files.length - 10} more files
-`));
-      }
-      console.log(chalk4__default.default.cyan(`
-S3 bucket: ${bucket}`));
+      spinner.info(chalk4__default.default.yellow("Dry run mode \u2014 no files will be uploaded"));
+      console.log();
+      console.log(chalk4__default.default.gray(`  bundle.zip: ${bundleSizeMB} MB`));
       console.log(
-        chalk4__default.default.cyan(`S3 path: s3://${bucket}/themes/${themeId}/${version}/
-`)
+        chalk4__default.default.cyan(
+          `  S3 path: s3://${bucket}/themes/${themeId}/${version}/bundle.zip`
+        )
       );
+      if (!options.skipSource) {
+        const sourceDir = await findSourceDir(themeId, options.sourceDir);
+        if (sourceDir) {
+          console.log(chalk4__default.default.gray(`  source dir: ${sourceDir}`));
+          console.log(
+            chalk4__default.default.cyan(
+              `  S3 path: s3://${bucket}/themes/${themeId}/${version}/source.zip`
+            )
+          );
+        } else {
+          console.log(
+            chalk4__default.default.yellow("  source dir: not found (source.zip will be skipped)")
+          );
+        }
+      }
+      console.log();
+      await fs__default.default.remove(bundleZipPath);
       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.start("Uploading bundle.zip to S3...");
+    const bundleS3Key = `themes/${themeId}/${version}/bundle.zip`;
+    await s3Client.send(
+      new clientS3.PutObjectCommand({
+        Bucket: bucket,
+        Key: bundleS3Key,
+        Body: bundleZipBuffer,
+        ContentType: "application/zip"
+      })
+    );
+    spinner.succeed(
+      `Uploaded bundle.zip ${chalk4__default.default.gray(`\u2192 s3://${bucket}/${bundleS3Key}`)}`
+    );
+    await fs__default.default.remove(bundleZipPath);
+    let sourceUploaded = false;
+    if (!options.skipSource) {
+      spinner.start("Looking for source directory...");
+      const sourceDir = await findSourceDir(themeId, options.sourceDir);
+      if (sourceDir) {
+        spinner.succeed(`Found source at: ${sourceDir}`);
+        spinner.start("Creating source.zip...");
+        const sourceZipPath = path__default.default.join(
+          tmpDir,
+          `${themeId}-${version}-source.zip`
+        );
+        await createZipFromDir(sourceDir, sourceZipPath, [
+          "node_modules/**",
+          "dist/**",
+          ".git/**",
+          "*.zip",
+          ".next/**",
+          ".turbo/**"
+        ]);
+        const sourceZipBuffer = await fs__default.default.readFile(sourceZipPath);
+        const sourceSizeMB = (sourceZipBuffer.length / 1024 / 1024).toFixed(2);
+        spinner.succeed(`Created source.zip (${sourceSizeMB} MB)`);
+        spinner.start("Uploading source.zip to S3...");
+        const sourceS3Key = `themes/${themeId}/${version}/source.zip`;
+        await s3Client.send(
+          new clientS3.PutObjectCommand({
+            Bucket: bucket,
+            Key: sourceS3Key,
+            Body: sourceZipBuffer,
+            ContentType: "application/zip"
+          })
+        );
+        spinner.succeed(
+          `Uploaded source.zip ${chalk4__default.default.gray(`\u2192 s3://${bucket}/${sourceS3Key}`)}`
+        );
+        await fs__default.default.remove(sourceZipPath);
+        sourceUploaded = true;
+      } else {
+        spinner.warn(
+          chalk4__default.default.yellow("Source directory not found \u2014 skipping source.zip")
+        );
+      }
     }
-    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__default.default.green.bold("\u2705 Theme uploaded successfully!"));
+    logger.success(chalk4__default.default.green.bold("Theme uploaded successfully!"));
     console.log();
     console.log(
       chalk4__default.default.cyan("   Theme:   ") + chalk4__default.default.white(`${themeId}@${version}`)
     );
     console.log(chalk4__default.default.cyan("   Bucket:  ") + chalk4__default.default.white(bucket));
-    console.log(chalk4__default.default.cyan("   Files:   ") + chalk4__default.default.white(total));
+    console.log(
+      chalk4__default.default.cyan("   Files:   ") + chalk4__default.default.white(
+        `bundle.zip${sourceUploaded ? " + source.zip" : ""}`
+      )
+    );
     console.log(
       chalk4__default.default.cyan("   Path:    ") + chalk4__default.default.gray(`s3://${bucket}/themes/${themeId}/${version}/`)
     );
@@ -1894,79 +1964,45 @@ async function resolveLatestVersion(s3Client, bucket, themeId) {
     );
   }
 }
-async function downloadManifest(s3Client, bucket, themeId, version) {
-  try {
-    const response = await s3Client.send(
-      new clientS3.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__default.default.join(outputDir, file);
-  await fs__default.default.ensureDir(path__default.default.dirname(localPath));
-  try {
-    const response = await s3Client.send(
-      new clientS3.GetObjectCommand({
-        Bucket: bucket,
-        Key: s3Key
-      })
-    );
-    const content = await streamToBuffer(response.Body);
-    await fs__default.default.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);
+async function createCompatibilityFiles(outputDir, manifest) {
+  var _a;
+  const entryFile = ((_a = manifest.output) == null ? void 0 : _a.entry) || "bundle-entry.js";
+  if (entryFile !== "bundle-entry.js" && entryFile.startsWith("bundle-entry-")) {
+    const hashedPath = path__default.default.join(outputDir, entryFile);
+    const stablePath = path__default.default.join(outputDir, "bundle-entry.js");
+    if (await fs__default.default.pathExists(hashedPath)) {
+      await fs__default.default.copy(hashedPath, stablePath);
+      const mapPath = hashedPath + ".map";
+      if (await fs__default.default.pathExists(mapPath)) {
+        await fs__default.default.copy(mapPath, stablePath + ".map");
+      }
     }
   }
-  return files;
-}
-async function createCompatibilityFiles(outputDir) {
   const sectionsRegistryPath = path__default.default.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__default.default.writeFile(sectionsRegistryPath, content, "utf-8");
+  const pkgJsonPath = path__default.default.join(outputDir, "package.json");
+  await fs__default.default.writeFile(pkgJsonPath, '{\n  "type": "module"\n}\n', "utf-8");
 }
 function showDownloadFailureHelp(themeId, bucket) {
   console.log();
-  logger.error(chalk4__default.default.red.bold("\u274C Theme download failed"));
+  logger.error(chalk4__default.default.red.bold("Theme download failed"));
   console.log();
   console.log(chalk4__default.default.yellow("Possible reasons:"));
   console.log(chalk4__default.default.gray("  1. Theme not uploaded to S3 yet"));
   console.log(chalk4__default.default.gray("  2. AWS credentials not configured correctly"));
   console.log(chalk4__default.default.gray("  3. Bucket name or region is incorrect"));
-  console.log(chalk4__default.default.gray("  4. Theme files are incomplete or corrupted"));
+  console.log(chalk4__default.default.gray("  4. bundle.zip is missing or corrupted"));
   console.log();
   console.log(chalk4__default.default.cyan.bold("To fix this:"));
   console.log();
   console.log(chalk4__default.default.white("1. Compile and upload the theme:"));
   console.log(chalk4__default.default.gray(`   cd themes/${themeId}`));
   console.log(chalk4__default.default.gray("   pnpm build"));
-  console.log(chalk4__default.default.gray("   pnpm upload"));
+  console.log(chalk4__default.default.gray("   onex upload"));
   console.log();
   console.log(chalk4__default.default.white("2. Verify AWS credentials are set:"));
   console.log(
@@ -1982,7 +2018,11 @@ function showDownloadFailureHelp(themeId, bucket) {
   );
   console.log();
   console.log(chalk4__default.default.white("4. Verify theme exists in S3:"));
-  console.log(chalk4__default.default.gray(`   aws s3 ls s3://${bucket}/themes/${themeId}/`));
+  console.log(
+    chalk4__default.default.gray(
+      `   aws s3 ls s3://${bucket}/themes/${themeId}/`
+    )
+  );
   console.log();
 }
 async function downloadCommand(options) {
@@ -2010,55 +2050,44 @@ async function downloadCommand(options) {
       spinner.succeed(
         `Resolved latest version: ${chalk4__default.default.cyan(resolvedVersion)}`
       );
-      spinner.start("Downloading manifest...");
     }
-    const manifest = await downloadManifest(
-      s3Client,
-      bucket,
-      themeId,
-      resolvedVersion
+    spinner.start(
+      `Downloading bundle.zip for ${themeId}@${resolvedVersion}...`
+    );
+    const s3Key = `themes/${themeId}/${resolvedVersion}/bundle.zip`;
+    const response = await s3Client.send(
+      new clientS3.GetObjectCommand({
+        Bucket: bucket,
+        Key: s3Key
+      })
     );
-    spinner.succeed("Downloaded manifest");
-    spinner.start("Preparing output directory...");
+    const zipBuffer = await streamToBuffer(response.Body);
+    const sizeMB = (zipBuffer.length / 1024 / 1024).toFixed(2);
+    spinner.succeed(`Downloaded bundle.zip (${sizeMB} MB)`);
+    spinner.start("Extracting bundle...");
     await fs__default.default.remove(outputDir);
     await fs__default.default.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);
+    const zip = new AdmZip__default.default(zipBuffer);
+    zip.extractAllTo(outputDir, true);
+    const entries = zip.getEntries().filter((e) => !e.isDirectory);
+    spinner.succeed(`Extracted ${entries.length} files to ${outputDir}`);
+    const manifestPath = path__default.default.join(outputDir, "manifest.json");
+    const manifest = await fs__default.default.readJson(manifestPath);
+    await createCompatibilityFiles(outputDir, manifest);
     console.log();
-    logger.success(chalk4__default.default.green.bold("\u2705 Theme downloaded successfully!"));
+    logger.success(chalk4__default.default.green.bold("Theme downloaded successfully!"));
     console.log();
     console.log(
       chalk4__default.default.cyan("   Theme:   ") + chalk4__default.default.white(`${themeId}@${resolvedVersion}`)
     );
     console.log(chalk4__default.default.cyan("   Bucket:  ") + chalk4__default.default.white(bucket));
     console.log(chalk4__default.default.cyan("   Output:  ") + chalk4__default.default.white(outputDir));
-    console.log(chalk4__default.default.cyan("   Files:   ") + chalk4__default.default.white(total));
-    console.log(
-      chalk4__default.default.cyan("   Sections:") + chalk4__default.default.white(` ${manifest.counts.sections}`)
-    );
+    console.log(chalk4__default.default.cyan("   Files:   ") + chalk4__default.default.white(entries.length));
+    if (manifest.counts) {
+      console.log(
+        chalk4__default.default.cyan("   Sections:") + chalk4__default.default.white(` ${manifest.counts.sections}`)
+      );
+    }
     console.log();
   } catch (error) {
     spinner.fail(chalk4__default.default.red("Download failed"));
@@ -2069,9 +2098,214 @@ async function downloadCommand(options) {
     process.exit(1);
   }
 }
+function getS3Client3() {
+  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 clientS3.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 clientS3.S3Client({
+      endpoint: "http://localhost:4569",
+      region: "ap-southeast-1",
+      credentials: {
+        accessKeyId: "S3RVER",
+        secretAccessKey: "S3RVER"
+      },
+      forcePathStyle: true
+    });
+  }
+  return new clientS3.S3Client({
+    region: process.env.AWS_REGION || "ap-southeast-1"
+  });
+}
+function getBucketName3(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 streamToString2(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 streamToBuffer2(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 resolveLatestVersion2(s3Client, bucket, themeId) {
+  try {
+    const response = await s3Client.send(
+      new clientS3.GetObjectCommand({
+        Bucket: bucket,
+        Key: `themes/${themeId}/latest.json`
+      })
+    );
+    const body = await streamToString2(response.Body);
+    return JSON.parse(body).version;
+  } catch (error) {
+    throw new Error(
+      `Failed to resolve latest version for theme "${themeId}": ${error.message}`
+    );
+  }
+}
+function runInstall(cwd) {
+  return new Promise((resolve) => {
+    const proc = child_process.spawn("pnpm", ["install"], {
+      cwd,
+      stdio: "inherit",
+      shell: true
+    });
+    proc.on("close", (code) => resolve(code === 0));
+    proc.on("error", () => resolve(false));
+  });
+}
+async function cloneCommand(themeName, options) {
+  logger.header("Clone Theme Source");
+  const spinner = ora__default.default("Initializing clone...").start();
+  try {
+    const bucket = options.bucket || getBucketName3(options.environment);
+    const outputDir = options.output || path__default.default.resolve(process.cwd(), themeName);
+    const s3Client = getS3Client3();
+    if (await fs__default.default.pathExists(outputDir)) {
+      spinner.fail(
+        chalk4__default.default.red(`Directory already exists: ${outputDir}`)
+      );
+      logger.info(
+        chalk4__default.default.gray(
+          "Use -o to specify a different output directory, or remove the existing directory."
+        )
+      );
+      process.exit(1);
+    }
+    let version = options.version || "latest";
+    if (version === "latest") {
+      spinner.text = "Resolving latest version...";
+      version = await resolveLatestVersion2(s3Client, bucket, themeName);
+      spinner.succeed(`Resolved latest version: ${chalk4__default.default.cyan(version)}`);
+    }
+    spinner.start(
+      `Downloading source.zip for ${themeName}@${version}...`
+    );
+    const s3Key = `themes/${themeName}/${version}/source.zip`;
+    let zipBuffer;
+    try {
+      const response = await s3Client.send(
+        new clientS3.GetObjectCommand({
+          Bucket: bucket,
+          Key: s3Key
+        })
+      );
+      zipBuffer = await streamToBuffer2(response.Body);
+    } catch (error) {
+      spinner.fail(chalk4__default.default.red(`Source not found: s3://${bucket}/${s3Key}`));
+      console.log();
+      console.log(
+        chalk4__default.default.yellow("The theme source may not have been uploaded yet.")
+      );
+      console.log(
+        chalk4__default.default.gray(
+          `Upload source with: onex upload --theme ${themeName}`
+        )
+      );
+      console.log();
+      process.exit(1);
+    }
+    const sizeMB = (zipBuffer.length / 1024 / 1024).toFixed(2);
+    spinner.succeed(`Downloaded source.zip (${sizeMB} MB)`);
+    spinner.start(`Extracting to ${outputDir}...`);
+    await fs__default.default.ensureDir(outputDir);
+    const zip = new AdmZip__default.default(zipBuffer);
+    zip.extractAllTo(outputDir, true);
+    const entries = zip.getEntries().filter((e) => !e.isDirectory);
+    spinner.succeed(`Extracted ${entries.length} files`);
+    if (options.install !== false) {
+      const hasPkgJson = await fs__default.default.pathExists(
+        path__default.default.join(outputDir, "package.json")
+      );
+      if (hasPkgJson) {
+        spinner.start("Installing dependencies...");
+        const success = await runInstall(outputDir);
+        if (success) {
+          spinner.succeed("Dependencies installed");
+        } else {
+          spinner.warn(
+            chalk4__default.default.yellow(
+              "Failed to install dependencies \u2014 run 'pnpm install' manually"
+            )
+          );
+        }
+      }
+    }
+    console.log();
+    logger.success(chalk4__default.default.green.bold("Theme cloned successfully!"));
+    console.log();
+    console.log(
+      chalk4__default.default.cyan("   Theme:    ") + chalk4__default.default.white(`${themeName}@${version}`)
+    );
+    console.log(chalk4__default.default.cyan("   Location: ") + chalk4__default.default.white(outputDir));
+    console.log(chalk4__default.default.cyan("   Files:    ") + chalk4__default.default.white(entries.length));
+    console.log();
+    console.log(chalk4__default.default.cyan("Next steps:"));
+    console.log(
+      chalk4__default.default.gray(`   cd ${path__default.default.relative(process.cwd(), outputDir)}`)
+    );
+    if (options.install === false) {
+      console.log(chalk4__default.default.gray("   pnpm install"));
+    }
+    console.log(chalk4__default.default.gray("   onex build"));
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk4__default.default.red(`Clone failed: ${error.message}`));
+    logger.error(error.stack || error.message);
+    process.exit(1);
+  }
+}
 
 exports.Logger = Logger;
 exports.buildCommand = buildCommand;
+exports.cloneCommand = cloneCommand;
 exports.copyTemplate = copyTemplate;
 exports.createBlockCommand = createBlockCommand;
 exports.createComponentCommand = createComponentCommand;