@onexapis/cli 1.1.42 → 1.1.44

package/dist/cli.mjs

@@ -749,6 +749,14 @@ async function compileStandaloneTheme(themePath, themeName) {
     } catch {
     }
     await contentHashEntry(outputDir);
+    const themeAssetsDir = path9.join(themePath, "assets");
+    const distThemeAssets = path9.join(outputDir, "theme-assets");
+    try {
+      await fs8.access(themeAssetsDir);
+      await fs8.cp(themeAssetsDir, distThemeAssets, { recursive: true });
+      logger.info("Copied static assets to dist/theme-assets/");
+    } catch {
+    }
     await generateManifest(themeName, themePath, outputDir);
     await generateThemeData(themePath, outputDir, themeName);
     await generateThemeCSS(themePath, outputDir);
@@ -4295,20 +4303,27 @@ function createDevServer(options) {
     if (pathname.startsWith("/assets/")) {
       const subpath = pathname.replace(/^\/assets\//, "");
       const segments = subpath.split("/");
+      const assetsBase = path9.join(options.themePath, "assets");
       let assetPath;
       if (segments[0] === options.themeName || segments[0] === options.themeName.replace(/^my-/, "")) {
-        assetPath = path9.join(
-          options.themePath,
-          "assets",
-          segments.slice(1).join("/")
-        );
+        assetPath = path9.join(assetsBase, segments.slice(1).join("/"));
       } else {
-        assetPath = path9.join(options.themePath, "assets", subpath);
+        assetPath = path9.join(assetsBase, subpath);
       }
-      if (assetPath.startsWith(path9.join(options.themePath, "assets")) && fs3.existsSync(assetPath)) {
+      if (assetPath.startsWith(assetsBase) && fs3.existsSync(assetPath)) {
         serveFile(res, assetPath);
         return;
       }
+      if (segments.length > 1) {
+        const fallbackPath = path9.join(
+          assetsBase,
+          segments.slice(1).join("/")
+        );
+        if (fallbackPath.startsWith(assetsBase) && fs3.existsSync(fallbackPath)) {
+          serveFile(res, fallbackPath);
+          return;
+        }
+      }
     }
     const filePath = path9.join(options.distDir, pathname);
     if (!filePath.startsWith(options.distDir)) {
@@ -4815,6 +4830,82 @@ async function whoamiCommand() {
 
 // src/commands/publish.ts
 init_logger();
+var MIME_MAP = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".bmp": "image/bmp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".ogg": "video/ogg",
+  ".json": "application/json"
+};
+var HASH_LEN = 8;
+function mimeFor(filename) {
+  const ext = path9.extname(filename).toLowerCase();
+  return MIME_MAP[ext] || "application/octet-stream";
+}
+async function sha256Prefix(absPath, len) {
+  const buf = await fs.readFile(absPath);
+  return crypto.createHash("sha256").update(buf).digest("hex").slice(0, len);
+}
+function insertHashIntoName(relPath, hash) {
+  const dir = path9.posix.dirname(relPath);
+  const base = path9.posix.basename(relPath);
+  const ext = path9.posix.extname(base);
+  const stem = ext ? base.slice(0, -ext.length) : base;
+  const hashed = `${stem}-${hash}${ext}`;
+  return dir === "." ? hashed : `${dir}/${hashed}`;
+}
+async function scanThemeAssets(distDir) {
+  const assetsDir = path9.join(distDir, "theme-assets");
+  if (!await fs.pathExists(assetsDir)) return [];
+  const files = await glob("**/*", {
+    cwd: assetsDir,
+    nodir: true,
+    dot: false
+  });
+  const results = [];
+  for (const rel of files) {
+    const absPath = path9.join(assetsDir, rel);
+    const stat = await fs.stat(absPath);
+    if (!stat.isFile()) continue;
+    const originalPath = rel.split(path9.sep).join("/");
+    const hash = await sha256Prefix(absPath, HASH_LEN);
+    const hashedPath = insertHashIntoName(originalPath, hash);
+    const contentType = mimeFor(rel);
+    results.push({
+      originalPath,
+      hashedPath,
+      hash,
+      size: stat.size,
+      contentType,
+      absPath
+    });
+  }
+  results.sort((a, b) => a.originalPath.localeCompare(b.originalPath));
+  return results;
+}
+function buildAssetMap(entries) {
+  const map = {};
+  for (const e of entries) {
+    map[e.originalPath] = e.hashedPath;
+  }
+  return map;
+}
+
+// src/commands/publish.ts
 async function publishCommand(options) {
   logger.header("OneX Theme Publish");
   const tokens = await getValidTokens();
@@ -4949,37 +5040,123 @@ Or use the --bump flag:
     logger.error(error instanceof Error ? error.message : "Build error");
     process.exit(1);
   }
-  logger.startSpinner("Getting upload URL...");
+  const distDir = path9.join(themePath, "dist");
+  let assetEntries = [];
+  try {
+    assetEntries = await scanThemeAssets(distDir);
+    if (assetEntries.length > 0) {
+      logger.info(`Found ${assetEntries.length} theme asset file(s)`);
+    }
+  } catch (error) {
+    logger.error(
+      `Asset scan failed: ${error instanceof Error ? error.message : "unknown"}`
+    );
+    process.exit(1);
+  }
+  try {
+    const assetMap = buildAssetMap(assetEntries);
+    const assetMapPath = path9.join(distDir, "asset-map.json");
+    await fs.writeFile(assetMapPath, JSON.stringify(assetMap, null, 2));
+  } catch (error) {
+    logger.error(
+      `Failed to write asset-map.json: ${error instanceof Error ? error.message : "unknown"}`
+    );
+    process.exit(1);
+  }
+  logger.startSpinner("Getting upload URLs...");
   let bundleUploadUrl;
   let sourceUploadUrl;
+  let assetUploads = [];
+  let alreadyUploaded = [];
   try {
     const pubResponse = await authenticatedFetch(
       `${apiUrl}/website-api/themes/${encodeURIComponent(themeId)}/versions`,
       {
         method: "POST",
-        body: JSON.stringify({ version: version2 })
+        body: JSON.stringify({
+          version: version2,
+          assets: assetEntries.map((a) => ({
+            path: a.hashedPath,
+            hash: a.hash,
+            size: a.size,
+            content_type: a.contentType
+          }))
+        })
       }
     );
     const pubData = await pubResponse.json();
     const pubBody = pubData.statusCode ? pubData.body : pubData;
     if (!pubResponse.ok || !pubBody.bundleUploadUrl) {
-      logger.stopSpinner(false, "Failed to get upload URL");
+      logger.stopSpinner(false, "Failed to get upload URLs");
       logger.error(pubBody.error || "Server error");
       process.exit(1);
     }
     bundleUploadUrl = pubBody.bundleUploadUrl;
     sourceUploadUrl = pubBody.sourceUploadUrl;
-    logger.stopSpinner(true, "Upload URL obtained");
+    assetUploads = pubBody.assetUploads || [];
+    alreadyUploaded = pubBody.alreadyUploaded || [];
+    logger.stopSpinner(
+      true,
+      `Upload URLs obtained (${assetUploads.length} new, ${alreadyUploaded.length} reused)`
+    );
   } catch (error) {
     logger.stopSpinner(false, "Failed");
     logger.error(error instanceof Error ? error.message : "Connection failed");
     process.exit(1);
   }
+  if (assetUploads.length > 0) {
+    logger.startSpinner(`Uploading ${assetUploads.length} asset(s) to S3...`);
+    const CONCURRENCY = 8;
+    const byHashedPath = new Map(assetEntries.map((a) => [a.hashedPath, a]));
+    const queue = [...assetUploads];
+    let uploaded = 0;
+    let failed = 0;
+    async function worker() {
+      while (queue.length > 0) {
+        const item = queue.shift();
+        if (!item) break;
+        const entry = byHashedPath.get(item.path);
+        if (!entry) {
+          failed++;
+          logger.error(`  \u2717 ${item.path}: no local file found`);
+          continue;
+        }
+        try {
+          const buf = await fs.promises.readFile(entry.absPath);
+          const res = await fetch(item.upload_url, {
+            method: "PUT",
+            headers: {
+              "Content-Type": entry.contentType,
+              "x-amz-acl": "public-read"
+            },
+            body: buf
+          });
+          if (!res.ok) {
+            throw new Error(`HTTP ${res.status}`);
+          }
+          uploaded++;
+        } catch (e) {
+          failed++;
+          logger.error(
+            `  \u2717 ${item.path}: ${e instanceof Error ? e.message : "failed"}`
+          );
+        }
+      }
+    }
+    await Promise.all(
+      Array.from(
+        { length: Math.min(CONCURRENCY, assetUploads.length) },
+        () => worker()
+      )
+    );
+    if (failed > 0) {
+      logger.stopSpinner(false, `${failed} asset(s) failed`);
+      process.exit(1);
+    }
+    logger.stopSpinner(true, `Uploaded ${uploaded} asset(s)`);
+  }
   logger.startSpinner("Uploading bundle...");
   try {
-    const archiver3 = await import('archiver');
-    const { createWriteStream } = await import('fs');
-    const distDir = path9.join(themePath, "dist");
     if (!fs.existsSync(distDir)) {
       logger.stopSpinner(false, "No dist/ directory");
       logger.error("Build the theme first: onexthm build");
@@ -4990,7 +5167,9 @@ Or use the --bump flag:
       "bundle.zip",
       "source.zip",
       "preview-runtime.js",
-      "preview-runtime.js.map"
+      "preview-runtime.js.map",
+      "theme-assets",
+      "theme-assets/**"
     ]);
     const bundleBuffer = fs.readFileSync(bundleZipPath);
     const bundleRes = await fetch(bundleUploadUrl, {