@onexapis/cli 1.1.36 → 1.1.38

package/dist/cli.mjs

@@ -2,18 +2,18 @@
 import chalk4 from 'chalk';
 import ora from 'ora';
 import * as esbuild from 'esbuild';
-import path8 from 'path';
-import fs7 from 'fs/promises';
-import crypto2 from 'crypto';
+import path10 from 'path';
+import fs9 from 'fs/promises';
+import crypto from 'crypto';
 import { glob } from 'glob';
 import { createRequire } from 'module';
-import os3 from 'os';
+import os from 'os';
 import dotenv from 'dotenv';
 import fs from 'fs-extra';
 import ejs from 'ejs';
-import { execSync, spawn } from 'child_process';
+import spawn2 from 'cross-spawn';
 import { Command } from 'commander';
-import fs2 from 'fs';
+import fs4 from 'fs';
 import inquirer from 'inquirer';
 import archiver from 'archiver';
 import FormData from 'form-data';
@@ -23,6 +23,7 @@ import AdmZip from 'adm-zip';
 import chokidar from 'chokidar';
 import http from 'http';
 import { WebSocketServer, WebSocket } from 'ws';
+import semver from 'semver';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -104,8 +105,8 @@ async function generateThemeCSS(themePath, outDir) {
     const tailwindcss = (await import('tailwindcss')).default;
     const tailwindConfig = {
       content: [
-        path8.join(themePath, "sections/**/*.{ts,tsx}"),
-        path8.join(themePath, "components/**/*.{ts,tsx}")
+        path10.join(themePath, "sections/**/*.{ts,tsx}"),
+        path10.join(themePath, "components/**/*.{ts,tsx}")
       ],
       theme: { extend: {} },
       plugins: []
@@ -115,7 +116,7 @@ async function generateThemeCSS(themePath, outDir) {
       inputCSS,
       { from: void 0 }
     );
-    await fs7.writeFile(path8.join(outDir, "bundle.css"), result.css);
+    await fs9.writeFile(path10.join(outDir, "bundle.css"), result.css);
     logger.info("Generated bundle.css");
   } catch (err) {
     logger.warning(
@@ -126,12 +127,12 @@ async function generateThemeCSS(themePath, outDir) {
 async function resolveNodeModulesFile(startDir, relativePath) {
   let dir = startDir;
   while (true) {
-    const candidate = path8.join(dir, "node_modules", relativePath);
+    const candidate = path10.join(dir, "node_modules", relativePath);
     try {
-      await fs7.access(candidate);
+      await fs9.access(candidate);
       return candidate;
     } catch {
-      const parent = path8.dirname(dir);
+      const parent = path10.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -155,7 +156,7 @@ async function scanImportsFromPackage(sourceDir, packageName) {
   });
   for (const file of sourceFiles) {
     try {
-      const content = await fs7.readFile(path8.join(sourceDir, file), "utf-8");
+      const content = await fs9.readFile(path10.join(sourceDir, file), "utf-8");
       for (const match of content.matchAll(namespaceImportRegex)) {
         const subpath = match[1] ? match[1].slice(1) : "";
         if (!result[subpath]) result[subpath] = /* @__PURE__ */ new Set();
@@ -209,17 +210,17 @@ function createCoreGlobalPlugin(themePath) {
           const distFileName = subpath ? `${subpath}.mjs` : "index.mjs";
           let distPath = await resolveNodeModulesFile(
             themePath,
-            path8.join("@onexapis", "core", "dist", distFileName)
+            path10.join("@onexapis", "core", "dist", distFileName)
           );
           if (!distPath) {
             distPath = await resolveNodeModulesFile(
               __dirname,
-              path8.join("@onexapis", "core", "dist", distFileName)
+              path10.join("@onexapis", "core", "dist", distFileName)
             );
           }
           try {
             if (!distPath) throw new Error("not found");
-            const distContent = await fs7.readFile(distPath, "utf-8");
+            const distContent = await fs9.readFile(distPath, "utf-8");
             const exportMatches = distContent.matchAll(/export\s*\{([^}]+)\}/g);
             for (const m of exportMatches) {
               const names = m[1].split(",").map((n) => {
@@ -448,7 +449,7 @@ async function generateThemeData(themePath, outputDir, themeId) {
   const pages = {};
   for (const ext of [".ts", ".js"]) {
     try {
-      const mod = await jiti.import(path8.join(themePath, `theme.config${ext}`));
+      const mod = await jiti.import(path10.join(themePath, `theme.config${ext}`));
       themeConfig = mod.default || mod;
       break;
     } catch {
@@ -456,20 +457,20 @@ async function generateThemeData(themePath, outputDir, themeId) {
   }
   for (const ext of [".ts", ".js"]) {
     try {
-      const mod = await jiti.import(path8.join(themePath, `theme.layout${ext}`));
+      const mod = await jiti.import(path10.join(themePath, `theme.layout${ext}`));
       layoutConfig = mod.default || mod;
       break;
     } catch {
     }
   }
   const schemas = {};
-  const sectionsDir = path8.join(themePath, "sections");
+  const sectionsDir = path10.join(themePath, "sections");
   try {
-    const sectionDirs = await fs7.readdir(sectionsDir);
+    const sectionDirs = await fs9.readdir(sectionsDir);
     for (const dir of sectionDirs) {
-      const schemaFile = path8.join(sectionsDir, dir, `${dir}.schema.ts`);
+      const schemaFile = path10.join(sectionsDir, dir, `${dir}.schema.ts`);
       try {
-        await fs7.access(schemaFile);
+        await fs9.access(schemaFile);
         const mod = await jiti.import(schemaFile);
         for (const [key, value] of Object.entries(mod)) {
           if (key.endsWith("Schema") && value && typeof value === "object" && value.type) {
@@ -481,14 +482,14 @@ async function generateThemeData(themePath, outputDir, themeId) {
     }
   } catch {
   }
-  const pagesDir = path8.join(themePath, "pages");
+  const pagesDir = path10.join(themePath, "pages");
   try {
-    const files = await fs7.readdir(pagesDir);
+    const files = await fs9.readdir(pagesDir);
     for (const file of files) {
       if (!file.match(/\.(ts|js)$/)) continue;
       const name = file.replace(/\.(ts|js)$/, "");
       try {
-        const mod = await jiti.import(path8.join(pagesDir, file));
+        const mod = await jiti.import(path10.join(pagesDir, file));
         const config = mod.default || mod;
         const sections = (config.sections || []).map((section) => {
           const schema = schemas[section.type];
@@ -516,8 +517,8 @@ async function generateThemeData(themePath, outputDir, themeId) {
     }
   } catch {
   }
-  await fs7.writeFile(
-    path8.join(outputDir, "theme-data.json"),
+  await fs9.writeFile(
+    path10.join(outputDir, "theme-data.json"),
     JSON.stringify(
       {
         themeId,
@@ -540,53 +541,53 @@ async function generateThemeData(themePath, outputDir, themeId) {
   logger.info(`Generated theme-data.json (${Object.keys(pages).length} pages)`);
 }
 async function contentHashEntry(outputDir) {
-  const entryPath = path8.join(outputDir, "bundle-entry.js");
-  const mapPath = path8.join(outputDir, "bundle-entry.js.map");
+  const entryPath = path10.join(outputDir, "bundle-entry.js");
+  const mapPath = path10.join(outputDir, "bundle-entry.js.map");
   const oldFiles = await glob("bundle-entry-*.js*", { cwd: outputDir });
   for (const f of oldFiles) {
-    await fs7.unlink(path8.join(outputDir, f));
+    await fs9.unlink(path10.join(outputDir, f));
   }
   let entryContent;
   try {
-    entryContent = await fs7.readFile(entryPath, "utf-8");
+    entryContent = await fs9.readFile(entryPath, "utf-8");
   } catch {
-    const indexPath = path8.join(outputDir, "index.js");
+    const indexPath = path10.join(outputDir, "index.js");
     try {
-      entryContent = await fs7.readFile(indexPath, "utf-8");
+      entryContent = await fs9.readFile(indexPath, "utf-8");
     } catch {
       logger.warning("No entry file found in output, skipping content hash");
       return;
     }
-    const hash2 = crypto2.createHash("sha256").update(entryContent).digest("hex").slice(0, 8);
+    const hash2 = crypto.createHash("sha256").update(entryContent).digest("hex").slice(0, 8);
     const hashedName2 = `bundle-entry-${hash2}.js`;
-    const indexMapPath = path8.join(outputDir, "index.js.map");
+    const indexMapPath = path10.join(outputDir, "index.js.map");
     const hashedMapName2 = `bundle-entry-${hash2}.js.map`;
     entryContent = entryContent.replace(
       /\/\/# sourceMappingURL=index\.js\.map/,
       `//# sourceMappingURL=${hashedMapName2}`
     );
-    await fs7.writeFile(path8.join(outputDir, hashedName2), entryContent);
-    await fs7.unlink(indexPath);
+    await fs9.writeFile(path10.join(outputDir, hashedName2), entryContent);
+    await fs9.unlink(indexPath);
     try {
-      await fs7.access(indexMapPath);
-      await fs7.rename(indexMapPath, path8.join(outputDir, hashedMapName2));
+      await fs9.access(indexMapPath);
+      await fs9.rename(indexMapPath, path10.join(outputDir, hashedMapName2));
     } catch {
     }
     logger.info(`Entry hashed: ${hashedName2}`);
     return;
   }
-  const hash = crypto2.createHash("sha256").update(entryContent).digest("hex").slice(0, 8);
+  const hash = crypto.createHash("sha256").update(entryContent).digest("hex").slice(0, 8);
   const hashedName = `bundle-entry-${hash}.js`;
   const hashedMapName = `bundle-entry-${hash}.js.map`;
   entryContent = entryContent.replace(
     /\/\/# sourceMappingURL=bundle-entry\.js\.map/,
     `//# sourceMappingURL=${hashedMapName}`
   );
-  await fs7.writeFile(path8.join(outputDir, hashedName), entryContent);
-  await fs7.unlink(entryPath);
+  await fs9.writeFile(path10.join(outputDir, hashedName), entryContent);
+  await fs9.unlink(entryPath);
   try {
-    await fs7.access(mapPath);
-    await fs7.rename(mapPath, path8.join(outputDir, hashedMapName));
+    await fs9.access(mapPath);
+    await fs9.rename(mapPath, path10.join(outputDir, hashedMapName));
   } catch {
   }
   logger.info(`Entry hashed: ${hashedName}`);
@@ -598,7 +599,7 @@ async function extractDataRequirements(themePath) {
   const requirements = {};
   for (const file of schemaFiles) {
     try {
-      const mod = await jiti.import(path8.join(themePath, file));
+      const mod = await jiti.import(path10.join(themePath, file));
       const exports$1 = mod;
       for (const value of Object.values(exports$1)) {
         if (value && typeof value === "object" && typeof value.type === "string" && value.dataRequirements && typeof value.dataRequirements === "object") {
@@ -617,8 +618,8 @@ async function generateManifest(themeName, themePath, outputDir) {
   let version2 = "1.0.0";
   let themeId = themeName;
   try {
-    const pkgContent = await fs7.readFile(
-      path8.join(themePath, "package.json"),
+    const pkgContent = await fs9.readFile(
+      path10.join(themePath, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(pkgContent);
@@ -636,7 +637,7 @@ async function generateManifest(themeName, themePath, outputDir) {
   const dataRequirements = await extractDataRequirements(themePath);
   let hasThemeConfig = false;
   try {
-    await fs7.access(path8.join(themePath, "theme.config.ts"));
+    await fs9.access(path10.join(themePath, "theme.config.ts"));
     hasThemeConfig = true;
   } catch {
   }
@@ -677,24 +678,24 @@ async function generateManifest(themeName, themePath, outputDir) {
     // Section data requirements for server-side prefetching (keyed by section type)
     dataRequirements
   };
-  await fs7.writeFile(
-    path8.join(outputDir, "manifest.json"),
+  await fs9.writeFile(
+    path10.join(outputDir, "manifest.json"),
     JSON.stringify(manifest, null, 2)
   );
 }
 async function compileStandaloneTheme(themePath, themeName) {
-  const outputDir = path8.join(themePath, "dist");
-  const bundleEntry = path8.join(themePath, "bundle-entry.ts");
-  const indexEntry = path8.join(themePath, "index.ts");
+  const outputDir = path10.join(themePath, "dist");
+  const bundleEntry = path10.join(themePath, "bundle-entry.ts");
+  const indexEntry = path10.join(themePath, "index.ts");
   let entryPoint = indexEntry;
   try {
-    await fs7.access(bundleEntry);
+    await fs9.access(bundleEntry);
     entryPoint = bundleEntry;
   } catch {
   }
-  const shimPath = path8.join(outputDir, ".process-shim.js");
-  await fs7.mkdir(outputDir, { recursive: true });
-  await fs7.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path10.join(outputDir, ".process-shim.js");
+  await fs9.mkdir(outputDir, { recursive: true });
+  await fs9.writeFile(shimPath, PROCESS_SHIM);
   const buildOptions = {
     entryPoints: [entryPoint],
     bundle: true,
@@ -744,7 +745,7 @@ async function compileStandaloneTheme(themePath, themeName) {
   try {
     const result = await esbuild.build(buildOptions);
     try {
-      await fs7.unlink(shimPath);
+      await fs9.unlink(shimPath);
     } catch {
     }
     await contentHashEntry(outputDir);
@@ -763,7 +764,7 @@ async function compileStandaloneTheme(themePath, themeName) {
     return true;
   } catch (error) {
     try {
-      await fs7.unlink(shimPath);
+      await fs9.unlink(shimPath);
     } catch {
     }
     logger.error(`esbuild compilation failed: ${error}`);
@@ -771,18 +772,18 @@ async function compileStandaloneTheme(themePath, themeName) {
   }
 }
 async function compileStandaloneThemeDev(themePath, themeName) {
-  const outputDir = path8.join(themePath, "dist");
-  const bundleEntry = path8.join(themePath, "bundle-entry.ts");
-  const indexEntry = path8.join(themePath, "index.ts");
+  const outputDir = path10.join(themePath, "dist");
+  const bundleEntry = path10.join(themePath, "bundle-entry.ts");
+  const indexEntry = path10.join(themePath, "index.ts");
   let entryPoint = indexEntry;
   try {
-    await fs7.access(bundleEntry);
+    await fs9.access(bundleEntry);
     entryPoint = bundleEntry;
   } catch {
   }
-  const shimPath = path8.join(outputDir, ".process-shim.js");
-  await fs7.mkdir(outputDir, { recursive: true });
-  await fs7.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path10.join(outputDir, ".process-shim.js");
+  await fs9.mkdir(outputDir, { recursive: true });
+  await fs9.writeFile(shimPath, PROCESS_SHIM);
   const buildOptions = {
     entryPoints: [entryPoint],
     bundle: true,
@@ -835,18 +836,18 @@ async function compileStandaloneThemeDev(themePath, themeName) {
   return { context: context2, outputDir };
 }
 async function compilePreviewRuntime(themePath) {
-  const outputDir = path8.join(themePath, "dist");
-  await fs7.mkdir(outputDir, { recursive: true });
-  const outputPath = path8.join(outputDir, "preview-runtime.js");
+  const outputDir = path10.join(themePath, "dist");
+  await fs9.mkdir(outputDir, { recursive: true });
+  const outputPath = path10.join(outputDir, "preview-runtime.js");
   const locations = [
-    path8.join(__dirname, "..", "preview", "preview-app.tsx"),
-    path8.join(__dirname, "preview", "preview-app.tsx"),
-    path8.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
+    path10.join(__dirname, "..", "preview", "preview-app.tsx"),
+    path10.join(__dirname, "preview", "preview-app.tsx"),
+    path10.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
   ];
   let previewEntryPath = null;
   for (const loc of locations) {
     try {
-      await fs7.access(loc);
+      await fs9.access(loc);
       previewEntryPath = loc;
       break;
     } catch {
@@ -929,10 +930,10 @@ ${locations.join("\n")}`
         if (!lucideScanned) {
           lucideScanned = true;
           const coreSrcCandidates = [
-            path8.join(themePath, "node_modules", "@onexapis", "core", "src"),
-            path8.join(themePath, "..", "..", "packages", "core", "src"),
+            path10.join(themePath, "node_modules", "@onexapis", "core", "src"),
+            path10.join(themePath, "..", "..", "packages", "core", "src"),
             // monorepo sibling
-            path8.join(
+            path10.join(
               __dirname,
               "..",
               "..",
@@ -947,7 +948,7 @@ ${locations.join("\n")}`
           let coreSourceDir = null;
           for (const candidate of coreSrcCandidates) {
             try {
-              await fs7.access(candidate);
+              await fs9.access(candidate);
               coreSourceDir = candidate;
               break;
             } catch {
@@ -966,21 +967,21 @@ ${locations.join("\n")}`
             }
           } else {
             const coreDistCandidates = [
-              path8.join(themePath, "node_modules", "@onexapis", "core", "dist")
+              path10.join(themePath, "node_modules", "@onexapis", "core", "dist")
             ];
             const resolvedDist = await resolveNodeModulesFile(
               __dirname,
-              path8.join("@onexapis", "core", "dist")
+              path10.join("@onexapis", "core", "dist")
             );
             if (resolvedDist) coreDistCandidates.push(resolvedDist);
             for (const candidate of coreDistCandidates) {
               try {
-                await fs7.access(candidate);
+                await fs9.access(candidate);
                 const mjsFiles = await glob("*.mjs", { cwd: candidate });
                 const importRegex = /import\s*\{([^}]+)\}\s*from\s*["']lucide-react["']/g;
                 for (const file of mjsFiles) {
-                  const content = await fs7.readFile(
-                    path8.join(candidate, file),
+                  const content = await fs9.readFile(
+                    path10.join(candidate, file),
                     "utf-8"
                   );
                   for (const match of content.matchAll(importRegex)) {
@@ -1035,7 +1036,7 @@ export default new Proxy({}, { get: (_, name) => name === '__esModule' ? true :
           const req = createRequire(import.meta.url || __filename);
           const cjsPath = req.resolve("framer-motion");
           const pkgDir = cjsPath.replace(/[/\\]dist[/\\].*$/, "");
-          const esmEntry = path8.join(pkgDir, "dist", "es", "index.mjs");
+          const esmEntry = path10.join(pkgDir, "dist", "es", "index.mjs");
           const { existsSync } = await import('fs');
           if (existsSync(esmEntry)) {
             return { path: esmEntry, namespace: "file" };
@@ -1134,8 +1135,8 @@ export function headers() { return new Headers(); }
       });
     }
   };
-  const shimPath = path8.join(outputDir, ".process-shim-preview.js");
-  await fs7.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path10.join(outputDir, ".process-shim-preview.js");
+  await fs9.writeFile(shimPath, PROCESS_SHIM);
   await esbuild.build({
     entryPoints: [previewEntryPath],
     bundle: true,
@@ -1170,7 +1171,7 @@ export function headers() { return new Headers(); }
     }
   });
   try {
-    await fs7.unlink(shimPath);
+    await fs9.unlink(shimPath);
   } catch {
   }
   return outputPath;
@@ -1303,18 +1304,18 @@ async function renderTemplate(templatePath, data) {
   return ejs.render(template, data);
 }
 async function writeFile(filePath, content) {
-  await fs.ensureDir(path8.dirname(filePath));
+  await fs.ensureDir(path10.dirname(filePath));
   await fs.writeFile(filePath, content, "utf-8");
 }
 function getTemplatesDir() {
   const locations = [
-    path8.join(__dirname, "../../templates"),
+    path10.join(__dirname, "../../templates"),
     // Development
-    path8.join(__dirname, "../templates"),
+    path10.join(__dirname, "../templates"),
     // Production (dist/)
-    path8.join(process.cwd(), "templates"),
+    path10.join(process.cwd(), "templates"),
     // Fallback
-    path8.join(process.cwd(), "packages/cli/templates")
+    path10.join(process.cwd(), "packages/cli/templates")
     // Monorepo
   ];
   for (const location of locations) {
@@ -1326,7 +1327,7 @@ function getTemplatesDir() {
 }
 async function copyTemplate(templateName, targetDir, data) {
   const templatesDir = getTemplatesDir();
-  const templateDir = path8.join(templatesDir, templateName);
+  const templateDir = path10.join(templatesDir, templateName);
   if (!fs.existsSync(templateDir)) {
     throw new Error(
       `Template "${templateName}" not found at ${templateDir}. Available templates: ${fs.readdirSync(templatesDir).join(", ")}`
@@ -1335,8 +1336,8 @@ async function copyTemplate(templateName, targetDir, data) {
   await fs.ensureDir(targetDir);
   const files = await fs.readdir(templateDir);
   for (const file of files) {
-    const templatePath = path8.join(templateDir, file);
-    const targetPath = path8.join(targetDir, file);
+    const templatePath = path10.join(templateDir, file);
+    const targetPath = path10.join(targetDir, file);
     const stat = await fs.stat(templatePath);
     if (stat.isDirectory()) {
       await copyTemplateDir(templatePath, targetPath, data);
@@ -1353,8 +1354,8 @@ async function copyTemplateDir(templateDir, targetDir, data) {
   await fs.ensureDir(targetDir);
   const files = await fs.readdir(templateDir);
   for (const file of files) {
-    const templatePath = path8.join(templateDir, file);
-    const targetPath = path8.join(targetDir, file);
+    const templatePath = path10.join(templateDir, file);
+    const targetPath = path10.join(targetDir, file);
     const stat = await fs.stat(templatePath);
     if (stat.isDirectory()) {
       await copyTemplateDir(templatePath, targetPath, data);
@@ -1369,32 +1370,32 @@ async function copyTemplateDir(templateDir, targetDir, data) {
 }
 function getProjectRoot() {
   let currentDir = process.cwd();
-  while (currentDir !== path8.parse(currentDir).root) {
-    const packageJsonPath = path8.join(currentDir, "package.json");
+  while (currentDir !== path10.parse(currentDir).root) {
+    const packageJsonPath = path10.join(currentDir, "package.json");
     if (fs.existsSync(packageJsonPath)) {
       const packageJson = fs.readJsonSync(packageJsonPath);
-      if (packageJson.workspaces || fs.existsSync(path8.join(currentDir, "src/themes")) || fs.existsSync(path8.join(currentDir, "themes"))) {
+      if (packageJson.workspaces || fs.existsSync(path10.join(currentDir, "src/themes")) || fs.existsSync(path10.join(currentDir, "themes"))) {
         return currentDir;
       }
     }
-    currentDir = path8.dirname(currentDir);
+    currentDir = path10.dirname(currentDir);
   }
   return process.cwd();
 }
 function getThemesDir() {
   const root = getProjectRoot();
-  if (fs.existsSync(path8.join(root, "themes")))
-    return path8.join(root, "themes");
-  if (fs.existsSync(path8.join(root, "src/themes")))
-    return path8.join(root, "src/themes");
-  return path8.dirname(root);
+  if (fs.existsSync(path10.join(root, "themes")))
+    return path10.join(root, "themes");
+  if (fs.existsSync(path10.join(root, "src/themes")))
+    return path10.join(root, "src/themes");
+  return path10.dirname(root);
 }
 function getFeaturesDir() {
-  return path8.join(getProjectRoot(), "src/features");
+  return path10.join(getProjectRoot(), "src/features");
 }
 function isOneXProject() {
   const root = getProjectRoot();
-  return fs.existsSync(path8.join(root, "themes")) || fs.existsSync(path8.join(root, "src/themes")) || fs.existsSync(path8.join(root, "theme.config.ts")) || fs.existsSync(path8.join(root, "bundle-entry.ts"));
+  return fs.existsSync(path10.join(root, "themes")) || fs.existsSync(path10.join(root, "src/themes")) || fs.existsSync(path10.join(root, "theme.config.ts")) || fs.existsSync(path10.join(root, "bundle-entry.ts"));
 }
 function ensureOneXProject() {
   if (!isOneXProject()) {
@@ -1410,13 +1411,13 @@ function listThemes() {
     return [];
   }
   return fs.readdirSync(themesDir).filter((name) => {
-    const themePath = path8.join(themesDir, name);
-    return fs.statSync(themePath).isDirectory() && (fs.existsSync(path8.join(themePath, "theme.config.ts")) || fs.existsSync(path8.join(themePath, "bundle-entry.ts")) || fs.existsSync(path8.join(themePath, "manifest.ts")));
+    const themePath = path10.join(themesDir, name);
+    return fs.statSync(themePath).isDirectory() && (fs.existsSync(path10.join(themePath, "theme.config.ts")) || fs.existsSync(path10.join(themePath, "bundle-entry.ts")) || fs.existsSync(path10.join(themePath, "manifest.ts")));
   });
 }
 function themeExists(themeName) {
-  const themePath = path8.join(getThemesDir(), themeName);
-  return fs.existsSync(themePath) && (fs.existsSync(path8.join(themePath, "theme.config.ts")) || fs.existsSync(path8.join(themePath, "bundle-entry.ts")) || fs.existsSync(path8.join(themePath, "manifest.ts")));
+  const themePath = path10.join(getThemesDir(), themeName);
+  return fs.existsSync(themePath) && (fs.existsSync(path10.join(themePath, "theme.config.ts")) || fs.existsSync(path10.join(themePath, "bundle-entry.ts")) || fs.existsSync(path10.join(themePath, "manifest.ts")));
 }
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent || "";
@@ -1424,24 +1425,22 @@ function detectPackageManager() {
   if (userAgent.includes("yarn")) return "yarn";
   if (userAgent.includes("bun")) return "bun";
   const cwd = process.cwd();
-  if (fs.existsSync(path8.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs.existsSync(path8.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs.existsSync(path8.join(cwd, "bun.lockb"))) return "bun";
+  if (fs.existsSync(path10.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path10.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs.existsSync(path10.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);
-    }
+  const args = packageManager === "yarn" ? [] : ["install"];
+  const result = spawn2.sync(packageManager, args, {
+    cwd: projectPath,
+    stdio: "inherit"
   });
+  if (result.status !== 0) {
+    throw new Error(
+      `${packageManager} install failed with exit code ${result.status}`
+    );
+  }
 }
 
 // src/commands/init.ts
@@ -1475,6 +1474,184 @@ function getValidCategories() {
     "contact"
   ];
 }
+var AUTH_DIR = path10.join(os.homedir(), ".onexthm");
+var AUTH_FILE = path10.join(AUTH_DIR, "auth.json");
+function getApiUrl() {
+  return process.env.ONEXTHM_API_URL || process.env.NEXT_PUBLIC_API_URL || "https://platform-dev.onexeos.com";
+}
+async function saveAuthTokens(tokens) {
+  await fs.ensureDir(AUTH_DIR);
+  const key = getMachineKey();
+  const data = JSON.stringify(tokens);
+  const encrypted = encrypt(data, key);
+  await fs.writeFile(AUTH_FILE, encrypted, "utf-8");
+}
+function loadAuthTokens() {
+  try {
+    if (!fs.existsSync(AUTH_FILE)) return null;
+    const encrypted = fs.readFileSync(AUTH_FILE, "utf-8");
+    const key = getMachineKey();
+    const data = decrypt(encrypted, key);
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+async function clearAuthTokens() {
+  try {
+    await fs.remove(AUTH_FILE);
+  } catch {
+  }
+}
+function isTokenExpired(tokens) {
+  return Date.now() / 1e3 > tokens.expiresAt - 60;
+}
+async function getValidTokens() {
+  const tokens = loadAuthTokens();
+  if (!tokens) return null;
+  if (!isTokenExpired(tokens)) return tokens;
+  try {
+    const apiUrl = getApiUrl();
+    const response = await fetch(`${apiUrl}/auth/refresh`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refresh_token: tokens.refreshToken })
+    });
+    if (!response.ok) {
+      await clearAuthTokens();
+      return null;
+    }
+    const data = await response.json();
+    const body = data.statusCode ? data.body : data;
+    const refreshed = {
+      ...tokens,
+      accessToken: body.AccessToken || tokens.accessToken,
+      idToken: body.IdToken || tokens.idToken,
+      expiresAt: Math.floor(Date.now() / 1e3) + (body.ExpiresIn || 3600)
+    };
+    await saveAuthTokens(refreshed);
+    return refreshed;
+  } catch {
+    await clearAuthTokens();
+    return null;
+  }
+}
+async function authenticatedFetch(url, init) {
+  const tokens = await getValidTokens();
+  if (!tokens) {
+    throw new Error("Not logged in. Run: onexthm login");
+  }
+  const headers = new Headers(init?.headers);
+  headers.set("Authorization", `Bearer ${tokens.idToken}`);
+  headers.set("Content-Type", "application/json");
+  return fetch(url, { ...init, headers });
+}
+function getMachineKey() {
+  let seed;
+  if (process.platform === "darwin") {
+    seed = `onexthm:${os.hostname()}:${os.userInfo().username}`;
+  } else if (process.platform === "linux") {
+    try {
+      seed = `onexthm:${fs.readFileSync("/etc/machine-id", "utf-8").trim()}`;
+    } catch {
+      seed = `onexthm:${os.hostname()}:${os.userInfo().username}`;
+    }
+  } else {
+    seed = `onexthm:${os.hostname()}:${os.userInfo().username}`;
+  }
+  return crypto.createHash("sha256").update(seed).digest();
+}
+function encrypt(text, key) {
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  let encrypted = cipher.update(text, "utf-8", "hex");
+  encrypted += cipher.final("hex");
+  const tag = cipher.getAuthTag();
+  return `${iv.toString("hex")}:${tag.toString("hex")}:${encrypted}`;
+}
+function decrypt(text, key) {
+  const [ivHex, tagHex, encrypted] = text.split(":");
+  const iv = Buffer.from(ivHex, "hex");
+  const tag = Buffer.from(tagHex, "hex");
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(tag);
+  let decrypted = decipher.update(encrypted, "hex", "utf-8");
+  decrypted += decipher.final("utf-8");
+  return decrypted;
+}
+function parseJwtClaims(idToken) {
+  try {
+    const payload = idToken.split(".")[1];
+    const decoded = Buffer.from(payload, "base64url").toString("utf-8");
+    return JSON.parse(decoded);
+  } catch {
+    return {};
+  }
+}
+function getNpxCommand() {
+  return process.platform === "win32" ? "npx.cmd" : "npx";
+}
+function getDefaultMcpConfig() {
+  return {
+    mcpServers: {
+      onexthm: {
+        command: getNpxCommand(),
+        args: ["-y", "@onexapis/theme-mcp"]
+      }
+    }
+  };
+}
+function ensureMcpJson(projectPath, figmaApiKey) {
+  const mcpJsonPath = path10.join(projectPath, ".mcp.json");
+  const npx = getNpxCommand();
+  let mcpConfig;
+  if (fs4.existsSync(mcpJsonPath)) {
+    try {
+      mcpConfig = JSON.parse(fs4.readFileSync(mcpJsonPath, "utf-8"));
+      if (!mcpConfig.mcpServers) {
+        mcpConfig.mcpServers = {};
+      }
+    } catch {
+      mcpConfig = getDefaultMcpConfig();
+    }
+  } else {
+    mcpConfig = getDefaultMcpConfig();
+  }
+  mcpConfig.mcpServers.onexthm = {
+    command: npx,
+    args: ["-y", "@onexapis/theme-mcp"]
+  };
+  if (figmaApiKey) {
+    mcpConfig.mcpServers.figma = {
+      command: npx,
+      args: [
+        "-y",
+        "figma-developer-mcp",
+        `--figma-api-key=${figmaApiKey}`,
+        "--stdio"
+      ]
+    };
+  } else {
+    delete mcpConfig.mcpServers.figma;
+  }
+  fs4.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + "\n");
+  ensureThemeMcpDependency(projectPath);
+}
+function ensureThemeMcpDependency(projectPath) {
+  const pkgJsonPath = path10.join(projectPath, "package.json");
+  if (!fs4.existsSync(pkgJsonPath)) return;
+  try {
+    const pkg = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
+    if (!pkg.devDependencies) {
+      pkg.devDependencies = {};
+    }
+    if (!pkg.devDependencies["@onexapis/theme-mcp"]) {
+      pkg.devDependencies["@onexapis/theme-mcp"] = "^0.1.0";
+      fs4.writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+    }
+  } catch {
+  }
+}
 
 // src/commands/init.ts
 async function initCommand(projectName, options = {}) {
@@ -1492,7 +1669,7 @@ async function initCommand(projectName, options = {}) {
           if (!validateThemeName(kebabName)) {
             return "Invalid project name. Use lowercase letters, numbers, and hyphens only.";
           }
-          if (fs2.existsSync(path8.join(process.cwd(), kebabName))) {
+          if (fs4.existsSync(path10.join(process.cwd(), kebabName))) {
             return `Directory "${kebabName}" already exists`;
           }
           return true;
@@ -1503,11 +1680,46 @@ async function initCommand(projectName, options = {}) {
   } else {
     name = toKebabCase(projectName);
   }
-  const projectPath = path8.join(process.cwd(), name);
-  if (fs2.existsSync(projectPath)) {
+  const projectPath = path10.join(process.cwd(), name);
+  if (fs4.existsSync(projectPath)) {
     logger.error(`Directory "${name}" already exists.`);
     process.exit(1);
   }
+  if (!options.yes) {
+    try {
+      const apiUrl = getApiUrl();
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 3e3);
+      const response = await fetch(
+        `${apiUrl}/website-api/themes/${encodeURIComponent(name)}/exists`,
+        { signal: controller.signal }
+      );
+      clearTimeout(timeout);
+      if (response.ok) {
+        const data2 = await response.json();
+        const body = data2.statusCode ? data2.body : data2;
+        if (body.exists && body.owner === "other") {
+          logger.warning(
+            `Theme ID "${name}" is already registered by another developer.
+  You can still create this locally, but publishing will fail.
+  Consider using a different name.`
+          );
+          const { proceed } = await inquirer.prompt([
+            {
+              type: "confirm",
+              name: "proceed",
+              message: "Continue anyway?",
+              default: false
+            }
+          ]);
+          if (!proceed) {
+            process.exit(0);
+          }
+        }
+      }
+    } catch {
+    }
+  }
   let displayName;
   let description;
   let author;
@@ -1575,7 +1787,7 @@ async function initCommand(projectName, options = {}) {
   }
   logger.startSpinner("Creating project structure...");
   try {
-    fs2.mkdirSync(projectPath, { recursive: true });
+    fs4.mkdirSync(projectPath, { recursive: true });
     await copyTemplate(template, projectPath, data);
     await renameThemeInFiles(
       projectPath,
@@ -1584,28 +1796,14 @@ async function initCommand(projectName, options = {}) {
       description,
       author
     );
-    const mcpJsonPath = path8.join(projectPath, ".mcp.json");
-    if (fs2.existsSync(mcpJsonPath)) {
-      let mcpContent = fs2.readFileSync(mcpJsonPath, "utf-8");
-      if (figmaApiKey) {
-        mcpContent = mcpContent.replace("__FIGMA_API_KEY__", figmaApiKey);
-      } else {
-        try {
-          const mcpJson = JSON.parse(mcpContent);
-          delete mcpJson.mcpServers.figma;
-          mcpContent = JSON.stringify(mcpJson, null, 2) + "\n";
-        } catch {
-        }
-      }
-      fs2.writeFileSync(mcpJsonPath, mcpContent, "utf-8");
-    }
+    ensureMcpJson(projectPath, figmaApiKey || void 0);
     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 onexthm init"', {
+        spawn2.sync("git", ["init"], { cwd: projectPath, stdio: "ignore" });
+        spawn2.sync("git", ["add", "."], { cwd: projectPath, stdio: "ignore" });
+        spawn2.sync("git", ["commit", "-m", "Initial commit from onexthm init"], {
           cwd: projectPath,
           stdio: "ignore"
         });
@@ -1657,16 +1855,16 @@ async function initCommand(projectName, options = {}) {
     logger.error(
       error instanceof Error ? error.message : "Unknown error occurred"
     );
-    if (fs2.existsSync(projectPath)) {
-      fs2.rmSync(projectPath, { recursive: true, force: true });
+    if (fs4.existsSync(projectPath)) {
+      fs4.rmSync(projectPath, { recursive: true, force: true });
     }
     process.exit(1);
   }
 }
 async function renameThemeInFiles(projectPath, themeName, displayName, description, author) {
-  const configPath = path8.join(projectPath, "theme.config.ts");
-  if (fs2.existsSync(configPath)) {
-    let content = fs2.readFileSync(configPath, "utf-8");
+  const configPath = path10.join(projectPath, "theme.config.ts");
+  if (fs4.existsSync(configPath)) {
+    let content = fs4.readFileSync(configPath, "utf-8");
     content = content.replace(
       /name: "My Simple Theme"/,
       `name: "${displayName}"`
@@ -1675,11 +1873,11 @@ async function renameThemeInFiles(projectPath, themeName, displayName, descripti
       /description: ".*?"/,
       `description: "${description}"`
     );
-    fs2.writeFileSync(configPath, content, "utf-8");
+    fs4.writeFileSync(configPath, content, "utf-8");
   }
-  const pkgPath = path8.join(projectPath, "package.json");
-  if (fs2.existsSync(pkgPath)) {
-    let content = fs2.readFileSync(pkgPath, "utf-8");
+  const pkgPath = path10.join(projectPath, "package.json");
+  if (fs4.existsSync(pkgPath)) {
+    let content = fs4.readFileSync(pkgPath, "utf-8");
     content = content.replace(
       /@onex-themes\/my-simple/g,
       `@onex-themes/${themeName}`
@@ -1688,7 +1886,7 @@ async function renameThemeInFiles(projectPath, themeName, displayName, descripti
       /"description": ".*?"/,
       `"description": "${description}"`
     );
-    fs2.writeFileSync(pkgPath, content, "utf-8");
+    fs4.writeFileSync(pkgPath, content, "utf-8");
   }
 }
 
@@ -1699,10 +1897,10 @@ async function createSectionCommand(name, options) {
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
-      (f) => fs.existsSync(path8.join(process.cwd(), f))
+      (f) => fs.existsSync(path10.join(process.cwd(), f))
     );
     if (isStandaloneTheme) {
-      options.theme = path8.basename(process.cwd());
+      options.theme = path10.basename(process.cwd());
     }
   }
   const sectionName = toKebabCase(name);
@@ -1765,35 +1963,35 @@ async function createSectionCommand(name, options) {
   };
   logger.startSpinner("Creating section files...");
   try {
-    const themePath = path8.join(getThemesDir(), themeName);
-    const sectionPath = path8.join(themePath, "sections", sectionName);
+    const themePath = path10.join(getThemesDir(), themeName);
+    const sectionPath = path10.join(themePath, "sections", sectionName);
     const schemaContent = generateSectionSchema(data);
     await writeFile(
-      path8.join(sectionPath, `${sectionName}.schema.ts`),
+      path10.join(sectionPath, `${sectionName}.schema.ts`),
       schemaContent
     );
     if (createTemplate) {
       const templateContent = generateSectionTemplate(data);
       await writeFile(
-        path8.join(sectionPath, `${sectionName}-default.tsx`),
+        path10.join(sectionPath, `${sectionName}-default.tsx`),
         templateContent
       );
     }
     const indexContent = generateSectionIndex(data, createTemplate);
-    await writeFile(path8.join(sectionPath, "index.ts"), indexContent);
+    await writeFile(path10.join(sectionPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Section files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path8.relative(process.cwd(), path8.join(sectionPath, `${sectionName}.schema.ts`))}`
+      `  1. Edit schema: ${path10.relative(process.cwd(), path10.join(sectionPath, `${sectionName}.schema.ts`))}`
     );
     if (createTemplate) {
       logger.log(
-        `  2. Edit template: ${path8.relative(process.cwd(), path8.join(sectionPath, `${sectionName}-default.tsx`))}`
+        `  2. Edit template: ${path10.relative(process.cwd(), path10.join(sectionPath, `${sectionName}-default.tsx`))}`
       );
     }
     logger.log(
-      `  3. Add to theme manifest: ${path8.relative(process.cwd(), path8.join(themePath, "manifest.ts"))}`
+      `  3. Add to theme manifest: ${path10.relative(process.cwd(), path10.join(themePath, "manifest.ts"))}`
     );
     logger.newLine();
     logger.success("Section created successfully!");
@@ -1941,10 +2139,10 @@ async function createBlockCommand(name, options) {
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
-      (f) => fs.existsSync(path8.join(process.cwd(), f))
+      (f) => fs.existsSync(path10.join(process.cwd(), f))
     );
     if (isStandaloneTheme) {
-      options.theme = path8.basename(process.cwd());
+      options.theme = path10.basename(process.cwd());
     }
   }
   const blockName = toKebabCase(name);
@@ -2019,24 +2217,24 @@ async function createBlockCommand(name, options) {
   };
   logger.startSpinner("Creating block files...");
   try {
-    const blockPath = scope === "shared" ? path8.join(getFeaturesDir(), "blocks", blockName) : path8.join(getThemesDir(), themeName, "blocks", blockName);
+    const blockPath = scope === "shared" ? path10.join(getFeaturesDir(), "blocks", blockName) : path10.join(getThemesDir(), themeName, "blocks", blockName);
     const schemaContent = generateBlockSchema(data);
     await writeFile(
-      path8.join(blockPath, `${blockName}.schema.ts`),
+      path10.join(blockPath, `${blockName}.schema.ts`),
       schemaContent
     );
     const componentContent = generateBlockComponent(data);
-    await writeFile(path8.join(blockPath, `${blockName}.tsx`), componentContent);
+    await writeFile(path10.join(blockPath, `${blockName}.tsx`), componentContent);
     const indexContent = generateBlockIndex(data);
-    await writeFile(path8.join(blockPath, "index.ts"), indexContent);
+    await writeFile(path10.join(blockPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Block files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path8.relative(process.cwd(), path8.join(blockPath, `${blockName}.schema.ts`))}`
+      `  1. Edit schema: ${path10.relative(process.cwd(), path10.join(blockPath, `${blockName}.schema.ts`))}`
     );
     logger.log(
-      `  2. Edit component: ${path8.relative(process.cwd(), path8.join(blockPath, `${blockName}.tsx`))}`
+      `  2. Edit component: ${path10.relative(process.cwd(), path10.join(blockPath, `${blockName}.tsx`))}`
     );
     logger.log(
       `  3. Register in block registry: src/lib/registry/block-registry.ts`
@@ -2214,31 +2412,31 @@ async function createComponentCommand(name, options) {
   };
   logger.startSpinner("Creating component files...");
   try {
-    const componentPath = path8.join(
+    const componentPath = path10.join(
       getFeaturesDir(),
       "components",
       componentName
     );
     const schemaContent = generateComponentSchema(data);
     await writeFile(
-      path8.join(componentPath, `${componentName}.schema.ts`),
+      path10.join(componentPath, `${componentName}.schema.ts`),
       schemaContent
     );
     const componentContent = generateComponent(data);
     await writeFile(
-      path8.join(componentPath, `${componentName}.tsx`),
+      path10.join(componentPath, `${componentName}.tsx`),
       componentContent
     );
     const indexContent = generateComponentIndex(data);
-    await writeFile(path8.join(componentPath, "index.ts"), indexContent);
+    await writeFile(path10.join(componentPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Component files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path8.relative(process.cwd(), path8.join(componentPath, `${componentName}.schema.ts`))}`
+      `  1. Edit schema: ${path10.relative(process.cwd(), path10.join(componentPath, `${componentName}.schema.ts`))}`
     );
     logger.log(
-      `  2. Edit component: ${path8.relative(process.cwd(), path8.join(componentPath, `${componentName}.tsx`))}`
+      `  2. Edit component: ${path10.relative(process.cwd(), path10.join(componentPath, `${componentName}.tsx`))}`
     );
     logger.log(
       `  3. Register in component registry: src/lib/registry/component-registry.ts`
@@ -2395,13 +2593,13 @@ async function listSections(themeFilter) {
     return;
   }
   for (const theme of themes) {
-    const sectionsDir = path8.join(getThemesDir(), theme, "sections");
+    const sectionsDir = path10.join(getThemesDir(), theme, "sections");
     if (!fs.existsSync(sectionsDir)) {
       continue;
     }
     const sections = fs.readdirSync(sectionsDir).filter((name) => {
-      const sectionPath = path8.join(sectionsDir, name);
-      return fs.statSync(sectionPath).isDirectory() && fs.existsSync(path8.join(sectionPath, "index.ts"));
+      const sectionPath = path10.join(sectionsDir, name);
+      return fs.statSync(sectionPath).isDirectory() && fs.existsSync(path10.join(sectionPath, "index.ts"));
     });
     if (sections.length > 0) {
       logger.log(chalk4.cyan(`
@@ -2415,11 +2613,11 @@ async function listSections(themeFilter) {
 }
 async function listBlocks(themeFilter) {
   logger.section("\u{1F9F1} Blocks");
-  const sharedBlocksDir = path8.join(getFeaturesDir(), "blocks");
+  const sharedBlocksDir = path10.join(getFeaturesDir(), "blocks");
   if (fs.existsSync(sharedBlocksDir)) {
     const sharedBlocks = fs.readdirSync(sharedBlocksDir).filter((name) => {
-      const blockPath = path8.join(sharedBlocksDir, name);
-      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path8.join(blockPath, "index.ts"));
+      const blockPath = path10.join(sharedBlocksDir, name);
+      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path10.join(blockPath, "index.ts"));
     });
     if (sharedBlocks.length > 0) {
       logger.log(chalk4.cyan("\n  Shared:"));
@@ -2430,13 +2628,13 @@ async function listBlocks(themeFilter) {
   }
   const themes = themeFilter ? [themeFilter] : listThemes();
   for (const theme of themes) {
-    const blocksDir = path8.join(getThemesDir(), theme, "blocks");
+    const blocksDir = path10.join(getThemesDir(), theme, "blocks");
     if (!fs.existsSync(blocksDir)) {
       continue;
     }
     const blocks = fs.readdirSync(blocksDir).filter((name) => {
-      const blockPath = path8.join(blocksDir, name);
-      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path8.join(blockPath, "index.ts"));
+      const blockPath = path10.join(blocksDir, name);
+      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path10.join(blockPath, "index.ts"));
     });
     if (blocks.length > 0) {
       logger.log(chalk4.cyan(`
@@ -2450,14 +2648,14 @@ async function listBlocks(themeFilter) {
 }
 async function listComponents() {
   logger.section("\u2699\uFE0F  Components");
-  const componentsDir = path8.join(getFeaturesDir(), "components");
+  const componentsDir = path10.join(getFeaturesDir(), "components");
   if (!fs.existsSync(componentsDir)) {
     logger.warning("No components directory found");
     return;
   }
   const components = fs.readdirSync(componentsDir).filter((name) => {
-    const componentPath = path8.join(componentsDir, name);
-    return fs.statSync(componentPath).isDirectory() && fs.existsSync(path8.join(componentPath, "index.ts"));
+    const componentPath = path10.join(componentsDir, name);
+    return fs.statSync(componentPath).isDirectory() && fs.existsSync(path10.join(componentPath, "index.ts"));
   });
   if (components.length === 0) {
     logger.warning("No components found");
@@ -2478,11 +2676,11 @@ async function listThemesInfo() {
   }
   logger.log("");
   for (const theme of themes) {
-    const themeDir = path8.join(getThemesDir(), theme);
+    const themeDir = path10.join(getThemesDir(), theme);
     const candidates = ["theme.config.ts", "bundle-entry.ts", "manifest.ts"];
     let manifestContent = "";
     for (const candidate of candidates) {
-      const candidatePath = path8.join(themeDir, candidate);
+      const candidatePath = path10.join(themeDir, candidate);
       if (fs.existsSync(candidatePath)) {
         manifestContent = fs.readFileSync(candidatePath, "utf-8");
         break;
@@ -2520,9 +2718,9 @@ async function validateCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path8.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path10.join(process.cwd(), f)));
     if (isThemeDir) {
-      themeToValidate = path8.basename(process.cwd());
+      themeToValidate = path10.basename(process.cwd());
       logger.info(`Validating current theme: ${themeToValidate}`);
     } else {
       logger.error(
@@ -2531,11 +2729,11 @@ async function validateCommand(options) {
       process.exit(1);
     }
   }
-  const themePath = path8.join(getThemesDir(), themeToValidate);
+  const themePath = path10.join(getThemesDir(), themeToValidate);
   logger.startSpinner("Running validation checks...");
   const entryFiles = ["manifest.ts", "theme.config.ts", "bundle-entry.ts"];
   const foundEntry = entryFiles.find(
-    (f) => fs.existsSync(path8.join(themePath, f))
+    (f) => fs.existsSync(path10.join(themePath, f))
   );
   if (!foundEntry) {
     issues.push({
@@ -2545,7 +2743,7 @@ async function validateCommand(options) {
     });
   } else if (foundEntry === "manifest.ts") {
     const manifestContent = fs.readFileSync(
-      path8.join(themePath, foundEntry),
+      path10.join(themePath, foundEntry),
       "utf-8"
     );
     if (!manifestContent.includes("export const") && !manifestContent.includes("export default") && !manifestContent.includes("export interface")) {
@@ -2556,7 +2754,7 @@ async function validateCommand(options) {
       });
     }
   }
-  const configPath = path8.join(themePath, "theme.config.ts");
+  const configPath = path10.join(themePath, "theme.config.ts");
   if (!fs.existsSync(configPath)) {
     issues.push({
       type: "warning",
@@ -2564,7 +2762,7 @@ async function validateCommand(options) {
       message: "Theme config file not found (recommended)"
     });
   }
-  const indexPath = path8.join(themePath, "index.ts");
+  const indexPath = path10.join(themePath, "index.ts");
   if (!fs.existsSync(indexPath)) {
     issues.push({
       type: "warning",
@@ -2572,7 +2770,7 @@ async function validateCommand(options) {
       message: "Index file not found (recommended)"
     });
   }
-  const sectionsDir = path8.join(themePath, "sections");
+  const sectionsDir = path10.join(themePath, "sections");
   if (!fs.existsSync(sectionsDir)) {
     issues.push({
       type: "warning",
@@ -2581,16 +2779,16 @@ async function validateCommand(options) {
     });
   } else {
     const sections = fs.readdirSync(sectionsDir).filter(
-      (name) => fs.statSync(path8.join(sectionsDir, name)).isDirectory()
+      (name) => fs.statSync(path10.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
-      const sectionPath = path8.join(sectionsDir, sectionName);
-      const schemaFile = path8.join(sectionPath, `${sectionName}.schema.ts`);
-      const defaultTemplate = path8.join(
+      const sectionPath = path10.join(sectionsDir, sectionName);
+      const schemaFile = path10.join(sectionPath, `${sectionName}.schema.ts`);
+      const defaultTemplate = path10.join(
         sectionPath,
         `${sectionName}-default.tsx`
       );
-      const indexFile = path8.join(sectionPath, "index.ts");
+      const indexFile = path10.join(sectionPath, "index.ts");
       if (!fs.existsSync(schemaFile)) {
         issues.push({
           type: "error",
@@ -2614,14 +2812,14 @@ async function validateCommand(options) {
       }
     }
   }
-  const blocksDir = path8.join(themePath, "blocks");
+  const blocksDir = path10.join(themePath, "blocks");
   if (fs.existsSync(blocksDir)) {
-    const blocks = fs.readdirSync(blocksDir).filter((name) => fs.statSync(path8.join(blocksDir, name)).isDirectory());
+    const blocks = fs.readdirSync(blocksDir).filter((name) => fs.statSync(path10.join(blocksDir, name)).isDirectory());
     for (const blockName of blocks) {
-      const blockPath = path8.join(blocksDir, blockName);
-      const schemaFile = path8.join(blockPath, `${blockName}.schema.ts`);
-      const componentFile = path8.join(blockPath, `${blockName}.tsx`);
-      const indexFile = path8.join(blockPath, "index.ts");
+      const blockPath = path10.join(blocksDir, blockName);
+      const schemaFile = path10.join(blockPath, `${blockName}.schema.ts`);
+      const componentFile = path10.join(blockPath, `${blockName}.tsx`);
+      const indexFile = path10.join(blockPath, "index.ts");
       if (!fs.existsSync(schemaFile)) {
         issues.push({
           type: "error",
@@ -2647,13 +2845,13 @@ async function validateCommand(options) {
   }
   if (fs.existsSync(sectionsDir)) {
     const sections = fs.readdirSync(sectionsDir).filter(
-      (name) => fs.statSync(path8.join(sectionsDir, name)).isDirectory()
+      (name) => fs.statSync(path10.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
-      const sectionPath = path8.join(sectionsDir, sectionName);
+      const sectionPath = path10.join(sectionsDir, sectionName);
       const tsxFiles = fs.readdirSync(sectionPath).filter((f) => f.endsWith(".tsx") && !f.endsWith(".schema.ts"));
       for (const tsxFile of tsxFiles) {
-        const filePath = path8.join(sectionPath, tsxFile);
+        const filePath = path10.join(sectionPath, tsxFile);
         const content = fs.readFileSync(filePath, "utf-8");
         const relPath = `sections/${sectionName}/${tsxFile}`;
         if (!content.includes('"use client"') && !content.includes("'use client'")) {
@@ -2701,23 +2899,46 @@ async function validateCommand(options) {
       }
     }
   }
-  const registryPath = path8.join(themePath, "sections-registry.ts");
-  const bundleEntryPath = path8.join(themePath, "bundle-entry.ts");
+  const registryPath = path10.join(themePath, "sections-registry.ts");
+  const bundleEntryPath = path10.join(themePath, "bundle-entry.ts");
   const registryContent = fs.existsSync(registryPath) ? fs.readFileSync(registryPath, "utf-8") : fs.existsSync(bundleEntryPath) ? fs.readFileSync(bundleEntryPath, "utf-8") : "";
   if (fs.existsSync(sectionsDir) && registryContent) {
     const sections = fs.readdirSync(sectionsDir).filter(
-      (name) => fs.statSync(path8.join(sectionsDir, name)).isDirectory()
+      (name) => fs.statSync(path10.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
       if (!registryContent.includes(`sections/${sectionName}`) && !registryContent.includes(`"${sectionName}"`)) {
         issues.push({
-          type: "warning",
+          type: "error",
           file: `sections/${sectionName}/`,
-          message: "Section not found in sections-registry.ts or bundle-entry.ts \u2014 may not be included in build"
+          message: "Section not exported in sections-registry.ts or bundle-entry.ts \u2014 will not be included in build"
         });
       }
     }
   }
+  if (fs.existsSync(sectionsDir)) {
+    const schemaTypes = await loadSchemaTypes(themePath, sectionsDir);
+    for (const { folderName, schemaType } of schemaTypes) {
+      if (schemaType && schemaType !== folderName) {
+        issues.push({
+          type: "error",
+          file: `sections/${folderName}/${folderName}.schema.ts`,
+          message: `Schema type "${schemaType}" doesn't match folder name "${folderName}". Rename folder to "${schemaType}/" or change schema type to "${folderName}".`
+        });
+      }
+    }
+    const pagesDir = path10.join(themePath, "pages");
+    if (fs.existsSync(pagesDir)) {
+      const allSchemaTypeSet = new Set(
+        schemaTypes.map((s) => s.schemaType || s.folderName)
+      );
+      const pageIssues = await validatePageSectionTypes(
+        pagesDir,
+        allSchemaTypeSet
+      );
+      issues.push(...pageIssues);
+    }
+  }
   logger.stopSpinner(true, "Validation complete");
   const errors = issues.filter((i) => i.type === "error");
   const warnings = issues.filter((i) => i.type === "warning");
@@ -2756,6 +2977,83 @@ async function validateCommand(options) {
     }
   }
 }
+async function loadSchemaTypes(themePath, sectionsDir) {
+  const results = [];
+  const sections = fs.readdirSync(sectionsDir).filter((name) => fs.statSync(path10.join(sectionsDir, name)).isDirectory());
+  for (const sectionName of sections) {
+    const schemaFile = path10.join(
+      sectionsDir,
+      sectionName,
+      `${sectionName}.schema.ts`
+    );
+    if (!fs.existsSync(schemaFile)) {
+      results.push({ folderName: sectionName, schemaType: null });
+      continue;
+    }
+    const content = fs.readFileSync(schemaFile, "utf-8");
+    const typeMatch = content.match(/\btype:\s*["']([^"']+)["']/);
+    results.push({
+      folderName: sectionName,
+      schemaType: typeMatch ? typeMatch[1] : null
+    });
+  }
+  return results;
+}
+async function validatePageSectionTypes(pagesDir, validTypes) {
+  const issues = [];
+  const files = fs.readdirSync(pagesDir).filter((f) => f.match(/\.(ts|js)$/));
+  for (const file of files) {
+    const content = fs.readFileSync(path10.join(pagesDir, file), "utf-8");
+    const pageName = file.replace(/\.(ts|js)$/, "");
+    const typeMatches = content.matchAll(/\btype:\s*["']([^"']+)["']/g);
+    for (const match of typeMatches) {
+      const sectionType = match[1];
+      if (isFieldType(sectionType)) continue;
+      if (!validTypes.has(sectionType)) {
+        issues.push({
+          type: "error",
+          file: `pages/${file}`,
+          message: `Page "${pageName}" uses section type "${sectionType}" which doesn't exist in sections/`
+        });
+      }
+    }
+  }
+  return issues;
+}
+var FIELD_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "textarea",
+  "richtext",
+  "number",
+  "range",
+  "toggle",
+  "switch",
+  "select",
+  "radio",
+  "checkbox",
+  "color",
+  "image",
+  "video",
+  "url",
+  "link",
+  "icon",
+  "date",
+  "datetime",
+  "collection",
+  "product",
+  "blog",
+  "page",
+  "html",
+  "code",
+  "json",
+  "array",
+  "object",
+  "group",
+  "section"
+]);
+function isFieldType(type) {
+  return FIELD_TYPES.has(type);
+}
 
 // src/commands/build.ts
 init_logger();
@@ -2766,14 +3064,14 @@ async function buildCommand(options) {
   if (options.theme) {
     themeName = options.theme;
     try {
-      const workspaceThemePath = path8.join(getThemesDir(), themeName);
+      const workspaceThemePath = path10.join(getThemesDir(), themeName);
       if (fs.existsSync(workspaceThemePath)) {
         themePath = workspaceThemePath;
       } else {
-        themePath = path8.join(process.cwd(), themeName);
+        themePath = path10.join(process.cwd(), themeName);
       }
     } catch {
-      themePath = path8.join(process.cwd(), themeName);
+      themePath = path10.join(process.cwd(), themeName);
     }
     if (!fs.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
@@ -2784,10 +3082,10 @@ async function buildCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path8.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path10.join(process.cwd(), f)));
     if (isThemeDir) {
       themePath = process.cwd();
-      themeName = path8.basename(themePath);
+      themeName = path10.basename(themePath);
       logger.info(`Building current theme: ${themeName}`);
     } else {
       logger.error(
@@ -2796,7 +3094,7 @@ async function buildCommand(options) {
       process.exit(1);
     }
   }
-  const packageJsonPath = path8.join(themePath, "package.json");
+  const packageJsonPath = path10.join(themePath, "package.json");
   const hasPkgJson = fs.existsSync(packageJsonPath);
   if (!hasPkgJson) {
     logger.warning(
@@ -2852,9 +3150,9 @@ async function buildCommand(options) {
     logger.success("\u2713 Theme built successfully!");
     logger.newLine();
     logger.info(`Theme: ${themeName}`);
-    const distPath = path8.join(themePath, "dist");
+    const distPath = path10.join(themePath, "dist");
     if (fs.existsSync(distPath)) {
-      logger.log(`Output: ${path8.relative(process.cwd(), distPath)}`);
+      logger.log(`Output: ${path10.relative(process.cwd(), distPath)}`);
       const files = fs.readdirSync(distPath);
       logger.log(`Files: ${files.length}`);
     }
@@ -2862,17 +3160,17 @@ async function buildCommand(options) {
 }
 function runCommand(command, args, cwd) {
   return new Promise((resolve) => {
-    const proc = spawn(command, args, {
+    const proc = spawn2(command, args, {
       cwd,
       stdio: ["pipe", "pipe", "pipe"],
       shell: true
     });
     let stdout = "";
     let stderr = "";
-    proc.stdout.on("data", (data) => {
+    proc.stdout?.on("data", (data) => {
       stdout += data.toString();
     });
-    proc.stderr.on("data", (data) => {
+    proc.stderr?.on("data", (data) => {
       stderr += data.toString();
     });
     proc.on("close", (code) => {
@@ -2910,7 +3208,7 @@ async function packageCommand(options) {
   let themeName;
   if (options.theme) {
     themeName = options.theme;
-    themePath = path8.join(getThemesDir(), themeName);
+    themePath = path10.join(getThemesDir(), themeName);
     if (!fs.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
       process.exit(1);
@@ -2920,10 +3218,10 @@ async function packageCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path8.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path10.join(process.cwd(), f)));
     if (isThemeDir) {
       themePath = process.cwd();
-      themeName = path8.basename(themePath);
+      themeName = path10.basename(themePath);
       logger.info(`Packaging current theme: ${themeName}`);
     } else {
       logger.error(
@@ -2932,7 +3230,7 @@ async function packageCommand(options) {
       process.exit(1);
     }
   }
-  const packageJsonPath = path8.join(themePath, "package.json");
+  const packageJsonPath = path10.join(themePath, "package.json");
   let version2 = "1.0.0";
   if (fs.existsSync(packageJsonPath)) {
     const packageJson = await fs.readJson(packageJsonPath);
@@ -2942,7 +3240,7 @@ async function packageCommand(options) {
   logger.info(`Theme: ${themeName}`);
   logger.info(`Version: ${version2}`);
   logger.newLine();
-  const compiledThemePath = path8.join(
+  const compiledThemePath = path10.join(
     process.cwd(),
     "themes",
     themeName,
@@ -2976,8 +3274,8 @@ async function packageCommand(options) {
   logger.newLine();
   logger.section("Step 2: Create Package");
   const packageName = options.name || `${themeName}-${version2}`;
-  const outputDir = options.output || path8.join(process.cwd(), "dist");
-  const outputPath = path8.join(outputDir, `${packageName}.zip`);
+  const outputDir = options.output || path10.join(process.cwd(), "dist");
+  const outputPath = path10.join(outputDir, `${packageName}.zip`);
   await fs.ensureDir(outputDir);
   logger.startSpinner("Creating zip archive...");
   try {
@@ -2990,11 +3288,11 @@ async function packageCommand(options) {
     logger.newLine();
     logger.info(`Package: ${packageName}.zip`);
     logger.log(`Size: ${sizeMB} MB`);
-    logger.log(`Location: ${path8.relative(process.cwd(), outputPath)}`);
+    logger.log(`Location: ${path10.relative(process.cwd(), outputPath)}`);
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  onexthm deploy --package ${path8.relative(process.cwd(), outputPath)}`
+      `  onexthm deploy --package ${path10.relative(process.cwd(), outputPath)}`
     );
   } catch (error) {
     logger.stopSpinner(false, "Failed to create package");
@@ -3006,13 +3304,13 @@ async function packageCommand(options) {
 }
 function runCommand2(command, args) {
   return new Promise((resolve) => {
-    const proc = spawn(command, args, {
+    const proc = spawn2(command, args, {
       cwd: process.cwd(),
       stdio: "pipe",
       shell: true
     });
     let hasError = false;
-    proc.stderr.on("data", (data) => {
+    proc.stderr?.on("data", (data) => {
       const message = data.toString();
       if (message.includes("error") || message.includes("Error") || message.includes("ERROR")) {
         hasError = true;
@@ -3052,9 +3350,9 @@ async function deployCommand(options) {
   ensureOneXProject();
   let packagePath;
   if (options.package) {
-    packagePath = path8.resolve(options.package);
+    packagePath = path10.resolve(options.package);
   } else if (options.theme) {
-    const distDir = path8.join(process.cwd(), "dist");
+    const distDir = path10.join(process.cwd(), "dist");
     if (!fs.existsSync(distDir)) {
       logger.error("No dist/ directory found. Run 'onexthm package' first.");
       process.exit(1);
@@ -3069,7 +3367,7 @@ async function deployCommand(options) {
       process.exit(1);
     }
     packageFiles.sort().reverse();
-    packagePath = path8.join(distDir, packageFiles[0]);
+    packagePath = path10.join(distDir, packageFiles[0]);
   } else {
     logger.error("Either --package or --theme must be specified.");
     logger.info("Examples:");
@@ -3083,11 +3381,11 @@ async function deployCommand(options) {
   }
   const stats = await fs.stat(packagePath);
   const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-  const fileName = path8.basename(packagePath);
+  const fileName = path10.basename(packagePath);
   logger.newLine();
   logger.info(`Package: ${fileName}`);
   logger.log(`Size: ${sizeMB} MB`);
-  logger.log(`Path: ${path8.relative(process.cwd(), packagePath)}`);
+  logger.log(`Path: ${path10.relative(process.cwd(), packagePath)}`);
   logger.newLine();
   const apiUrl = options.apiUrl || process.env.ONEX_API_URL || "http://localhost:3001";
   const uploadEndpoint = `${apiUrl}/website-api/themes/upload`;
@@ -3191,11 +3489,11 @@ function getBucketName(env) {
   return environment === "production" ? "theme-s3-bucket" : "theme-s3-bucket";
 }
 async function findCompiledThemeDir(themeId, version2) {
-  const searchPaths = [path8.resolve(process.cwd(), "dist")];
+  const searchPaths = [path10.resolve(process.cwd(), "dist")];
   for (const dir of searchPaths) {
     if (await fs.pathExists(dir)) {
-      const hasManifest = await fs.pathExists(path8.join(dir, "manifest.json"));
-      const hasThemeEntry = await fs.pathExists(path8.join(dir, "bundle-entry.js")) || await fs.pathExists(path8.join(dir, "theme.config.js")) || await fs.pathExists(path8.join(dir, "index.js"));
+      const hasManifest = await fs.pathExists(path10.join(dir, "manifest.json"));
+      const hasThemeEntry = await fs.pathExists(path10.join(dir, "bundle-entry.js")) || await fs.pathExists(path10.join(dir, "theme.config.js")) || await fs.pathExists(path10.join(dir, "index.js"));
       if (hasManifest || hasThemeEntry) {
         return dir;
       }
@@ -3204,7 +3502,7 @@ async function findCompiledThemeDir(themeId, version2) {
   return null;
 }
 async function readManifest() {
-  const manifestTsPath = path8.resolve(process.cwd(), "manifest.ts");
+  const manifestTsPath = path10.resolve(process.cwd(), "manifest.ts");
   if (await fs.pathExists(manifestTsPath)) {
     try {
       const module = await import(manifestTsPath);
@@ -3213,7 +3511,7 @@ async function readManifest() {
       logger.warning("Failed to import manifest.ts, trying package.json");
     }
   }
-  const packageJsonPath = path8.resolve(process.cwd(), "package.json");
+  const packageJsonPath = path10.resolve(process.cwd(), "package.json");
   if (await fs.pathExists(packageJsonPath)) {
     const pkg = await fs.readJson(packageJsonPath);
     return {
@@ -3247,13 +3545,13 @@ async function findSourceDir(themeId, explicitDir) {
   }
   const searchPaths = [
     process.cwd(),
-    path8.resolve(process.cwd(), `../../themes/${themeId}`),
-    path8.resolve(process.cwd(), `../themes/${themeId}`)
+    path10.resolve(process.cwd(), `../../themes/${themeId}`),
+    path10.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.pathExists(path8.join(dir, marker))) {
+      if (await fs.pathExists(path10.join(dir, marker))) {
         return dir;
       }
     }
@@ -3304,8 +3602,8 @@ async function uploadCommand(options) {
     }
     spinner.succeed(`Found compiled theme at: ${compiledDir}`);
     spinner.start("Creating bundle.zip...");
-    const tmpDir = os3.tmpdir();
-    const bundleZipPath = path8.join(tmpDir, `${themeId}-${version2}-bundle.zip`);
+    const tmpDir = os.tmpdir();
+    const bundleZipPath = path10.join(tmpDir, `${themeId}-${version2}-bundle.zip`);
     await createZipFromDir(compiledDir, bundleZipPath);
     const bundleZipBuffer = await fs.readFile(bundleZipPath);
     const bundleSizeMB = (bundleZipBuffer.length / 1024 / 1024).toFixed(2);
@@ -3359,7 +3657,7 @@ async function uploadCommand(options) {
       if (sourceDir) {
         spinner.succeed(`Found source at: ${sourceDir}`);
         spinner.start("Creating source.zip...");
-        const sourceZipPath = path8.join(
+        const sourceZipPath = path10.join(
           tmpDir,
           `${themeId}-${version2}-source.zip`
         );
@@ -3493,8 +3791,8 @@ async function resolveLatestVersion(s3Client, bucket, themeId) {
 async function createCompatibilityFiles(outputDir, manifest) {
   const entryFile = manifest.output?.entry || "bundle-entry.js";
   if (entryFile !== "bundle-entry.js" && entryFile.startsWith("bundle-entry-")) {
-    const hashedPath = path8.join(outputDir, entryFile);
-    const stablePath = path8.join(outputDir, "bundle-entry.js");
+    const hashedPath = path10.join(outputDir, entryFile);
+    const stablePath = path10.join(outputDir, "bundle-entry.js");
     if (await fs.pathExists(hashedPath)) {
       await fs.copy(hashedPath, stablePath);
       const mapPath = hashedPath + ".map";
@@ -3503,13 +3801,13 @@ async function createCompatibilityFiles(outputDir, manifest) {
       }
     }
   }
-  const sectionsRegistryPath = path8.join(outputDir, "sections-registry.js");
+  const sectionsRegistryPath = path10.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");
-  const pkgJsonPath = path8.join(outputDir, "package.json");
+  const pkgJsonPath = path10.join(outputDir, "package.json");
   await fs.writeFile(pkgJsonPath, '{\n  "type": "module"\n}\n', "utf-8");
 }
 function showDownloadFailureHelp(themeId, bucket) {
@@ -3571,6 +3869,18 @@ async function downloadCommand(options) {
       spinner.succeed(
         `Resolved latest version: ${chalk4.cyan(resolvedVersion)}`
       );
+      const isCI = !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.VERCEL);
+      if (isCI) {
+        console.log(
+          chalk4.yellow(
+            `
+  Warning: Resolved "latest" to ${resolvedVersion} in CI environment.
+  For production builds, pin to a specific version:
+    THEME_VERSION=${resolvedVersion}
+`
+          )
+        );
+      }
     }
     spinner.start(
       `Downloading bundle.zip for ${themeId}@${resolvedVersion}...`
@@ -3592,7 +3902,7 @@ async function downloadCommand(options) {
     zip.extractAllTo(outputDir, true);
     const entries = zip.getEntries().filter((e) => !e.isDirectory);
     spinner.succeed(`Extracted ${entries.length} files to ${outputDir}`);
-    const manifestPath = path8.join(outputDir, "manifest.json");
+    const manifestPath = path10.join(outputDir, "manifest.json");
     const manifest = await fs.readJson(manifestPath);
     await createCompatibilityFiles(outputDir, manifest);
     console.log();
@@ -3692,10 +4002,9 @@ async function resolveLatestVersion2(s3Client, bucket, themeId) {
 }
 function runInstall(cwd) {
   return new Promise((resolve) => {
-    const proc = spawn("pnpm", ["install"], {
+    const proc = spawn2("pnpm", ["install"], {
       cwd,
-      stdio: "inherit",
-      shell: true
+      stdio: "inherit"
     });
     proc.on("close", (code) => resolve(code === 0));
     proc.on("error", () => resolve(false));
@@ -3726,7 +4035,7 @@ async function renameTheme(themeDir, oldName, newName) {
   const oldPrefix = `${oldName}-`;
   const newPrefix = `${newName}-`;
   const newDisplayName = newName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-  const pkgPath = path8.join(themeDir, "package.json");
+  const pkgPath = path10.join(themeDir, "package.json");
   if (await fs.pathExists(pkgPath)) {
     const pkg = await fs.readJson(pkgPath);
     pkg.name = `@onex-themes/${newName}`;
@@ -3742,7 +4051,7 @@ async function renameTheme(themeDir, oldName, newName) {
     }
     await fs.writeJson(pkgPath, pkg, { spaces: 2 });
   }
-  const configPath = path8.join(themeDir, "theme.config.ts");
+  const configPath = path10.join(themeDir, "theme.config.ts");
   if (await fs.pathExists(configPath)) {
     let content = await fs.readFile(configPath, "utf-8");
     content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
@@ -3752,7 +4061,7 @@ async function renameTheme(themeDir, oldName, newName) {
     );
     await fs.writeFile(configPath, content);
   }
-  const layoutPath = path8.join(themeDir, "theme.layout.ts");
+  const layoutPath = path10.join(themeDir, "theme.layout.ts");
   if (await fs.pathExists(layoutPath)) {
     let content = await fs.readFile(layoutPath, "utf-8");
     content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
@@ -3765,7 +4074,7 @@ async function renameTheme(themeDir, oldName, newName) {
   const oldDisplayName = oldName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
   const tsFiles = await glob("**/*.ts", { cwd: themeDir, nodir: true });
   for (const file of tsFiles) {
-    const filePath = path8.join(themeDir, file);
+    const filePath = path10.join(themeDir, file);
     let content = await fs.readFile(filePath, "utf-8");
     const original = content;
     content = content.replace(
@@ -3794,7 +4103,7 @@ async function cloneCommand(themeName, options) {
   const spinner = ora("Initializing clone...").start();
   try {
     const bucket = options.bucket || getBucketName3(options.environment);
-    const outputDir = options.output || path8.resolve(process.cwd(), newName);
+    const outputDir = options.output || path10.resolve(process.cwd(), newName);
     const s3Client = getS3Client3();
     if (await fs.pathExists(outputDir)) {
       spinner.fail(chalk4.red(`Directory already exists: ${outputDir}`));
@@ -3849,7 +4158,7 @@ async function cloneCommand(themeName, options) {
     spinner.succeed(
       `Renamed theme: ${chalk4.gray(themeName)} \u2192 ${chalk4.cyan(newName)}`
     );
-    const envExamplePath = path8.join(outputDir, ".env.example");
+    const envExamplePath = path10.join(outputDir, ".env.example");
     if (!await fs.pathExists(envExamplePath)) {
       await fs.writeFile(
         envExamplePath,
@@ -3862,32 +4171,18 @@ async function cloneCommand(themeName, options) {
         ].join("\n")
       );
     }
-    const mcpJsonPath = path8.join(outputDir, ".mcp.json");
-    if (await fs.pathExists(mcpJsonPath)) {
-      const { default: inquirerMod } = await import('inquirer');
-      const { figmaApiKey } = await inquirerMod.prompt([
-        {
-          type: "password",
-          name: "figmaApiKey",
-          message: "Figma API Key (optional, for Figma-to-code MCP \u2014 press Enter to skip):"
-        }
-      ]);
-      let mcpContent = await fs.readFile(mcpJsonPath, "utf-8");
-      if (figmaApiKey) {
-        mcpContent = mcpContent.replace("__FIGMA_API_KEY__", figmaApiKey);
-      } else {
-        try {
-          const mcpJson = JSON.parse(mcpContent);
-          delete mcpJson.mcpServers?.figma;
-          mcpContent = JSON.stringify(mcpJson, null, 2) + "\n";
-        } catch {
-        }
+    const { default: inquirerMod } = await import('inquirer');
+    const { figmaApiKey } = await inquirerMod.prompt([
+      {
+        type: "password",
+        name: "figmaApiKey",
+        message: "Figma API Key (optional, for Figma-to-code MCP \u2014 press Enter to skip):"
       }
-      await fs.writeFile(mcpJsonPath, mcpContent, "utf-8");
-    }
+    ]);
+    ensureMcpJson(outputDir, figmaApiKey || void 0);
     if (options.install !== false) {
       const hasPkgJson = await fs.pathExists(
-        path8.join(outputDir, "package.json")
+        path10.join(outputDir, "package.json")
       );
       if (hasPkgJson) {
         spinner.start("Installing dependencies...");
@@ -3914,9 +4209,10 @@ async function cloneCommand(themeName, options) {
     console.log(chalk4.cyan("   Files:    ") + chalk4.white(entries.length));
     console.log();
     console.log(chalk4.cyan("Next steps:"));
-    console.log(chalk4.gray(`   cd ${path8.relative(process.cwd(), outputDir)}`));
+    console.log(chalk4.gray(`   cd ${path10.relative(process.cwd(), outputDir)}`));
+    const copyCmd = process.platform === "win32" ? "copy .env.example .env" : "cp .env.example .env";
     console.log(
-      chalk4.gray("   cp .env.example .env  # then add your Company ID")
+      chalk4.gray(`   ${copyCmd}  # then add your Company ID`)
     );
     if (options.install === false) {
       console.log(chalk4.gray("   pnpm install"));
@@ -3949,7 +4245,7 @@ var MIME_TYPES = {
 };
 function createDevServer(options) {
   const clients = /* @__PURE__ */ new Set();
-  const themeDataPath = path8.join(options.distDir, "theme-data.json");
+  const themeDataPath = path10.join(options.distDir, "theme-data.json");
   const server = http.createServer((req, res) => {
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
@@ -3975,8 +4271,8 @@ function createDevServer(options) {
     if (pathname.startsWith("/_assets/")) {
       const parts = pathname.replace(/^\/_assets\//, "").split("/");
       const assetSubpath = parts.slice(1).join("/");
-      const assetPath = path8.join(options.themePath, "assets", assetSubpath);
-      if (!assetPath.startsWith(path8.join(options.themePath, "assets"))) {
+      const assetPath = path10.join(options.themePath, "assets", assetSubpath);
+      if (!assetPath.startsWith(path10.join(options.themePath, "assets"))) {
         res.writeHead(403);
         res.end("Forbidden");
         return;
@@ -3987,8 +4283,8 @@ function createDevServer(options) {
     if (pathname.startsWith("/themes/")) {
       const match = pathname.match(/^\/themes\/[^/]+\/assets\/(.+)/);
       if (match) {
-        const assetPath = path8.join(options.themePath, "assets", match[1]);
-        if (!assetPath.startsWith(path8.join(options.themePath, "assets"))) {
+        const assetPath = path10.join(options.themePath, "assets", match[1]);
+        if (!assetPath.startsWith(path10.join(options.themePath, "assets"))) {
           res.writeHead(403);
           res.end("Forbidden");
           return;
@@ -4002,26 +4298,26 @@ function createDevServer(options) {
       const segments = subpath.split("/");
       let assetPath;
       if (segments[0] === options.themeName || segments[0] === options.themeName.replace(/^my-/, "")) {
-        assetPath = path8.join(
+        assetPath = path10.join(
           options.themePath,
           "assets",
           segments.slice(1).join("/")
         );
       } else {
-        assetPath = path8.join(options.themePath, "assets", subpath);
+        assetPath = path10.join(options.themePath, "assets", subpath);
       }
-      if (assetPath.startsWith(path8.join(options.themePath, "assets")) && fs2.existsSync(assetPath)) {
+      if (assetPath.startsWith(path10.join(options.themePath, "assets")) && fs4.existsSync(assetPath)) {
         serveFile(res, assetPath);
         return;
       }
     }
-    const filePath = path8.join(options.distDir, pathname);
+    const filePath = path10.join(options.distDir, pathname);
     if (!filePath.startsWith(options.distDir)) {
       res.writeHead(403);
       res.end("Forbidden");
       return;
     }
-    if (fs2.existsSync(filePath) && fs2.statSync(filePath).isFile()) {
+    if (fs4.existsSync(filePath) && fs4.statSync(filePath).isFile()) {
       serveFile(res, filePath);
     } else {
       res.writeHead(200, { "Content-Type": "text/html" });
@@ -4053,14 +4349,14 @@ function createDevServer(options) {
 }
 function serveFile(res, filePath) {
   try {
-    if (!fs2.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       res.writeHead(404);
       res.end("Not Found");
       return;
     }
-    const ext = path8.extname(filePath);
+    const ext = path10.extname(filePath);
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
-    const content = fs2.readFileSync(filePath);
+    const content = fs4.readFileSync(filePath);
     res.writeHead(200, { "Content-Type": contentType });
     res.end(content);
   } catch {
@@ -4073,7 +4369,7 @@ function generatePreviewHTML(themeName, port, themeDataPath) {
   let fontVarsCSS = "";
   if (themeDataPath) {
     try {
-      const themeData = JSON.parse(fs2.readFileSync(themeDataPath, "utf-8"));
+      const themeData = JSON.parse(fs4.readFileSync(themeDataPath, "utf-8"));
       const typography = (themeData?.themeConfig || themeData?.theme?.config)?.typography?.fontFamily;
       if (typography) {
         const fontFamilies = /* @__PURE__ */ new Set();
@@ -4161,14 +4457,14 @@ async function devCommand(options) {
   if (options.theme) {
     themeName = options.theme;
     try {
-      const workspaceThemePath = path8.join(getThemesDir(), themeName);
+      const workspaceThemePath = path10.join(getThemesDir(), themeName);
       if (fs.existsSync(workspaceThemePath)) {
         themePath = workspaceThemePath;
       } else {
-        themePath = path8.join(process.cwd(), themeName);
+        themePath = path10.join(process.cwd(), themeName);
       }
     } catch {
-      themePath = path8.join(process.cwd(), themeName);
+      themePath = path10.join(process.cwd(), themeName);
     }
     if (!fs.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
@@ -4179,10 +4475,10 @@ async function devCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path8.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path10.join(process.cwd(), f)));
     if (isThemeDir) {
       themePath = process.cwd();
-      themeName = path8.basename(themePath);
+      themeName = path10.basename(themePath);
     } else {
       logger.error(
         "Not in a theme directory and no --theme specified. Run from theme root or use --theme flag."
@@ -4251,9 +4547,9 @@ async function devCommand(options) {
     watcher.close();
     await context2.dispose();
     server.close();
-    const shimPath = path8.join(outputDir, ".process-shim.js");
+    const shimPath = path10.join(outputDir, ".process-shim.js");
     try {
-      await fs7.unlink(shimPath);
+      await fs9.unlink(shimPath);
     } catch {
     }
     process.exit(0);
@@ -4262,8 +4558,8 @@ async function devCommand(options) {
 
 // src/commands/config.ts
 init_logger();
-var CONFIG_DIR = path8.join(os3.homedir(), ".onexthm");
-var CONFIG_FILE = path8.join(CONFIG_DIR, ".env");
+var CONFIG_DIR = path10.join(os.homedir(), ".onexthm");
+var CONFIG_FILE = path10.join(CONFIG_DIR, ".env");
 var CONFIG_ENTRIES = [
   {
     key: "AWS_ACCESS_KEY_ID",
@@ -4405,122 +4701,6 @@ async function configCommand() {
 
 // src/commands/login.ts
 init_logger();
-var AUTH_DIR = path8.join(os3.homedir(), ".onexthm");
-var AUTH_FILE = path8.join(AUTH_DIR, "auth.json");
-function getApiUrl() {
-  return process.env.ONEXTHM_API_URL || process.env.NEXT_PUBLIC_API_URL || "https://platform-dev.onexeos.com";
-}
-async function saveAuthTokens(tokens) {
-  await fs.ensureDir(AUTH_DIR);
-  const key = getMachineKey();
-  const data = JSON.stringify(tokens);
-  const encrypted = encrypt(data, key);
-  await fs.writeFile(AUTH_FILE, encrypted, "utf-8");
-}
-function loadAuthTokens() {
-  try {
-    if (!fs.existsSync(AUTH_FILE)) return null;
-    const encrypted = fs.readFileSync(AUTH_FILE, "utf-8");
-    const key = getMachineKey();
-    const data = decrypt(encrypted, key);
-    return JSON.parse(data);
-  } catch {
-    return null;
-  }
-}
-async function clearAuthTokens() {
-  try {
-    await fs.remove(AUTH_FILE);
-  } catch {
-  }
-}
-function isTokenExpired(tokens) {
-  return Date.now() / 1e3 > tokens.expiresAt - 60;
-}
-async function getValidTokens() {
-  const tokens = loadAuthTokens();
-  if (!tokens) return null;
-  if (!isTokenExpired(tokens)) return tokens;
-  try {
-    const apiUrl = getApiUrl();
-    const response = await fetch(`${apiUrl}/auth/refresh`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ refresh_token: tokens.refreshToken })
-    });
-    if (!response.ok) {
-      await clearAuthTokens();
-      return null;
-    }
-    const data = await response.json();
-    const body = data.statusCode ? data.body : data;
-    const refreshed = {
-      ...tokens,
-      accessToken: body.AccessToken || tokens.accessToken,
-      idToken: body.IdToken || tokens.idToken,
-      expiresAt: Math.floor(Date.now() / 1e3) + (body.ExpiresIn || 3600)
-    };
-    await saveAuthTokens(refreshed);
-    return refreshed;
-  } catch {
-    await clearAuthTokens();
-    return null;
-  }
-}
-async function authenticatedFetch(url, init) {
-  const tokens = await getValidTokens();
-  if (!tokens) {
-    throw new Error("Not logged in. Run: onexthm login");
-  }
-  const headers = new Headers(init?.headers);
-  headers.set("Authorization", `Bearer ${tokens.idToken}`);
-  headers.set("Content-Type", "application/json");
-  return fetch(url, { ...init, headers });
-}
-function getMachineKey() {
-  let seed;
-  if (process.platform === "darwin") {
-    seed = `onexthm:${os3.hostname()}:${os3.userInfo().username}`;
-  } else if (process.platform === "linux") {
-    try {
-      seed = `onexthm:${fs.readFileSync("/etc/machine-id", "utf-8").trim()}`;
-    } catch {
-      seed = `onexthm:${os3.hostname()}:${os3.userInfo().username}`;
-    }
-  } else {
-    seed = `onexthm:${os3.hostname()}:${os3.userInfo().username}`;
-  }
-  return crypto2.createHash("sha256").update(seed).digest();
-}
-function encrypt(text, key) {
-  const iv = crypto2.randomBytes(16);
-  const cipher = crypto2.createCipheriv("aes-256-gcm", key, iv);
-  let encrypted = cipher.update(text, "utf-8", "hex");
-  encrypted += cipher.final("hex");
-  const tag = cipher.getAuthTag();
-  return `${iv.toString("hex")}:${tag.toString("hex")}:${encrypted}`;
-}
-function decrypt(text, key) {
-  const [ivHex, tagHex, encrypted] = text.split(":");
-  const iv = Buffer.from(ivHex, "hex");
-  const tag = Buffer.from(tagHex, "hex");
-  const decipher = crypto2.createDecipheriv("aes-256-gcm", key, iv);
-  decipher.setAuthTag(tag);
-  let decrypted = decipher.update(encrypted, "hex", "utf-8");
-  decrypted += decipher.final("utf-8");
-  return decrypted;
-}
-function parseJwtClaims(idToken) {
-  try {
-    const payload = idToken.split(".")[1];
-    const decoded = Buffer.from(payload, "base64url").toString("utf-8");
-    return JSON.parse(decoded);
-  } catch {
-    return {};
-  }
-}
-
-// src/commands/login.ts
 async function loginCommand() {
   logger.header("OneX Theme Developer Login");
   const existing = loadAuthTokens();
@@ -4646,13 +4826,13 @@ async function publishCommand(options) {
   logger.info(`Logged in as: ${tokens.user.email}`);
   let themePath;
   if (options.theme) {
-    themePath = path8.resolve(options.theme);
+    themePath = path10.resolve(options.theme);
   } else {
     const isThemeDir = [
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path8.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path10.join(process.cwd(), f)));
     if (isThemeDir) {
       themePath = process.cwd();
     } else {
@@ -4662,14 +4842,31 @@ async function publishCommand(options) {
       process.exit(1);
     }
   }
-  const pkgPath = path8.join(themePath, "package.json");
+  const pkgPath = path10.join(themePath, "package.json");
   if (!fs.existsSync(pkgPath)) {
     logger.error("No package.json found in theme directory");
     process.exit(1);
   }
   const pkg = fs.readJsonSync(pkgPath);
-  const themeId = pkg.name?.replace("@onex-themes/", "") || path8.basename(themePath);
+  const themeId = pkg.name?.replace("@onex-themes/", "") || path10.basename(themePath);
+  if (options.bump) {
+    const currentVersion = pkg.version || "1.0.0";
+    const newVersion = semver.inc(currentVersion, options.bump);
+    if (!newVersion) {
+      logger.error(`Failed to bump version from ${currentVersion}`);
+      process.exit(1);
+    }
+    pkg.version = newVersion;
+    fs.writeJsonSync(pkgPath, pkg, { spaces: 2 });
+    logger.info(`Bumped version: ${currentVersion} -> ${newVersion}`);
+  }
   const version2 = pkg.version || "1.0.0";
+  if (!semver.valid(version2)) {
+    logger.error(
+      `Invalid version "${version2}" in package.json. Must be valid semver (e.g., 1.0.0)`
+    );
+    process.exit(1);
+  }
   logger.newLine();
   logger.info(`Theme: ${themeId}`);
   logger.info(`Version: ${version2}`);
@@ -4685,7 +4882,11 @@ async function publishCommand(options) {
           themeId,
           name: pkg.displayName || themeId,
           description: pkg.description || "",
-          email: tokens.user.email
+          email: tokens.user.email,
+          author: typeof pkg.author === "string" ? pkg.author : pkg.author?.name || tokens.user.name || "",
+          category: pkg.onex?.category || "MINIMAL",
+          tags: pkg.keywords || [],
+          thumbnail_url: pkg.onex?.thumbnail || ""
         })
       }
     );
@@ -4702,6 +4903,38 @@ async function publishCommand(options) {
     logger.error(error instanceof Error ? error.message : "Connection failed");
     process.exit(1);
   }
+  logger.startSpinner("Checking version availability...");
+  try {
+    const checkResponse = await authenticatedFetch(
+      `${apiUrl}/website-api/themes/${encodeURIComponent(themeId)}/versions/${encodeURIComponent(version2)}/exists`,
+      { method: "GET" }
+    );
+    const checkData = await checkResponse.json();
+    const checkBody = checkData.statusCode ? checkData.body : checkData;
+    if (checkBody.exists) {
+      logger.stopSpinner(false, "Version already published");
+      const patchVer = semver.inc(version2, "patch") || "?";
+      const minorVer = semver.inc(version2, "minor") || "?";
+      const majorVer = semver.inc(version2, "major") || "?";
+      logger.error(
+        `
+Version ${version2} of "${themeId}" is already published and cannot be overwritten.
+
+To publish a new version:
+  1. Bump version in package.json (e.g., ${version2} -> ${patchVer})
+  2. Run: onexthm publish
+
+Or use the --bump flag:
+  onexthm publish --bump patch    (${version2} -> ${patchVer})
+  onexthm publish --bump minor    (${version2} -> ${minorVer})
+  onexthm publish --bump major    (${version2} -> ${majorVer})`
+      );
+      process.exit(1);
+    }
+    logger.stopSpinner(true, `Version ${version2} is available`);
+  } catch (error) {
+    logger.stopSpinner(true, "Version check skipped (endpoint not available)");
+  }
   logger.startSpinner("Building theme...");
   try {
     const { compileStandaloneTheme: compileStandaloneTheme2 } = await Promise.resolve().then(() => (init_compile_theme(), compile_theme_exports));
@@ -4747,13 +4980,13 @@ async function publishCommand(options) {
   try {
     const archiver3 = await import('archiver');
     const { createWriteStream } = await import('fs');
-    const distDir = path8.join(themePath, "dist");
+    const distDir = path10.join(themePath, "dist");
     if (!fs.existsSync(distDir)) {
       logger.stopSpinner(false, "No dist/ directory");
       logger.error("Build the theme first: onexthm build");
       process.exit(1);
     }
-    const bundleZipPath = path8.join(themePath, "dist", "bundle.zip");
+    const bundleZipPath = path10.join(themePath, "dist", "bundle.zip");
     await createZip(distDir, bundleZipPath, [
       "bundle.zip",
       "source.zip",
@@ -4778,7 +5011,7 @@ async function publishCommand(options) {
   }
   logger.startSpinner("Uploading source...");
   try {
-    const sourceZipPath = path8.join(themePath, "dist", "source.zip");
+    const sourceZipPath = path10.join(themePath, "dist", "source.zip");
     await createZip(themePath, sourceZipPath, [
       "node_modules",
       "dist",
@@ -4866,14 +5099,14 @@ async function createZip(sourceDir, outputPath, exclude) {
 try {
   const projectRoot = getProjectRoot();
   dotenv.config({
-    path: path8.join(projectRoot, ".env.local"),
+    path: path10.join(projectRoot, ".env.local"),
     quiet: true
   });
-  dotenv.config({ path: path8.join(projectRoot, ".env"), quiet: true });
+  dotenv.config({ path: path10.join(projectRoot, ".env"), quiet: true });
 } catch {
 }
 dotenv.config({
-  path: path8.join(os3.homedir(), ".onexthm", ".env"),
+  path: path10.join(os.homedir(), ".onexthm", ".env"),
   quiet: true
 });
 var require2 = createRequire(import.meta.url);
@@ -4933,7 +5166,10 @@ program.command("config").description("Configure OneX CLI credentials (AWS, API
 program.command("login").description("Login to OneX platform").action(loginCommand);
 program.command("logout").description("Logout from OneX platform").action(logoutCommand);
 program.command("whoami").description("Show current logged-in developer").action(whoamiCommand);
-program.command("publish").description("Build, scan, and publish theme to marketplace (requires login)").option("-t, --theme <path>", "Theme directory path").action(publishCommand);
+program.command("publish").description("Build, scan, and publish theme to marketplace (requires login)").option("-t, --theme <path>", "Theme directory path").option(
+  "--bump <type>",
+  "Auto-bump version before publish (patch|minor|major)"
+).action(publishCommand);
 program.configureOutput({
   writeErr: (str) => process.stderr.write(chalk4.red(str))
 });