tiendu 0.4.0 → 0.6.0

package/lib/dev.mjs

@@ -1,58 +1,120 @@
 import { watch } from "node:fs";
-import { readFile, readdir, stat } from "node:fs/promises";
+import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import * as p from "@clack/prompts";
-import { zipSync } from "fflate";
-import { loadConfigOrFail, writeConfig, isBuiltTheme, getDistDir } from "./config.mjs";
+import { loadConfigOrFail, isBuiltTheme, getDistDir } from "./config.mjs";
 import {
-  createPreview,
-  listPreviews,
-  resolveActivePreview,
+  fetchPreviewDetails,
+  resolvePreviewKeyInteractively,
 } from "./preview.mjs";
 import {
   deletePreviewFile,
   uploadPreviewFileMultipart,
-  uploadPreviewZip,
 } from "./api.mjs";
 import { build } from "./build.mjs";
+import { isDotfile } from "./fs-utils.mjs";
+import { startLocalPreviewServer } from "./local-preview.mjs";
+import { pushPreparedDirectoryToPreview } from "./push.mjs";
+import { retryAsync } from "./retry.mjs";
 
-const isDotfile = (name) => name.startsWith(".");
-
-const buildPreviewUrl = (apiBaseUrl, previewHostname) => {
-  const base = new URL(apiBaseUrl);
-  const hasExplicitPort = previewHostname.includes(":");
-  return `${base.protocol}//${previewHostname}${!hasExplicitPort && base.port ? `:${base.port}` : ""}/`;
-};
+const RETRY_ATTEMPTS = 3;
+const MAX_SYNC_FILE_SIZE_BYTES = 20 * 1024 * 1024;
+const CLEANUP_TIMEOUT_MS = 5_000;
+const IGNORED_ROOT_SEGMENTS = new Set(["node_modules", ".git"]);
 
 const hasDotfileSegment = (relativePath) =>
   relativePath.split(path.sep).some(isDotfile);
 
-const listAllFiles = async (rootDir, currentDir) => {
-  const entries = await readdir(currentDir, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    if (isDotfile(entry.name)) continue;
-    const abs = path.join(currentDir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...(await listAllFiles(rootDir, abs)));
-    } else if (entry.isFile()) {
-      files.push(abs);
-    }
+const shouldIgnoreWatchedPath = (relativePath, builtTheme) => {
+  const normalizedPath = relativePath.split(path.sep).join("/");
+  const segments = normalizedPath.split("/");
+  const basename = segments.at(-1) ?? "";
+
+  if (segments.some((segment) => IGNORED_ROOT_SEGMENTS.has(segment))) {
+    return true;
   }
-  return files;
+
+  if (!builtTheme && segments[0] === "dist") {
+    return true;
+  }
+
+  return basename.endsWith("~") || /\.(swp|tmp|temp)$/i.test(basename);
 };
 
-const createZipFromDirectory = async (rootDir) => {
-  const absoluteFiles = await listAllFiles(rootDir, rootDir);
-  /** @type {Record<string, Uint8Array>} */
-  const entries = {};
-  for (const abs of absoluteFiles) {
-    const rel = path.relative(rootDir, abs).split(path.sep).join("/");
-    entries[rel] = new Uint8Array(await readFile(abs));
+const shouldRetrySyncResult = (result) =>
+  !result.ok && Boolean(result.retriable);
+
+const runCleanupStep = async (label, cleanupFn) => {
+  if (!cleanupFn) return;
+
+  let timeoutId = null;
+
+  try {
+    await Promise.race([
+      Promise.resolve().then(() => cleanupFn()),
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new Error(`${label} did not finish within ${CLEANUP_TIMEOUT_MS}ms.`));
+        }, CLEANUP_TIMEOUT_MS);
+      }),
+    ]);
+  } catch (error) {
+    p.log.warn(error.message);
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
   }
-  return Buffer.from(zipSync(entries, { level: 6 }));
 };
 
+const uploadFileWithRetries = (
+  apiBaseUrl,
+  apiKey,
+  storeId,
+  previewKey,
+  relativePath,
+  content,
+  onRetry,
+) =>
+  retryAsync(
+    () =>
+      uploadPreviewFileMultipart(
+        apiBaseUrl,
+        apiKey,
+        storeId,
+        previewKey,
+        relativePath,
+        content,
+      ),
+    {
+      attempts: RETRY_ATTEMPTS,
+      shouldRetry: shouldRetrySyncResult,
+      onRetry,
+    },
+  );
+
+const deleteFileWithRetries = (
+  apiBaseUrl,
+  apiKey,
+  storeId,
+  previewKey,
+  relativePath,
+  onRetry,
+) =>
+  retryAsync(
+    () =>
+      deletePreviewFile(
+        apiBaseUrl,
+        apiKey,
+        storeId,
+        previewKey,
+        relativePath,
+      ),
+    {
+      attempts: RETRY_ATTEMPTS,
+      shouldRetry: shouldRetrySyncResult,
+      onRetry,
+    },
+  );
+
 export const dev = async () => {
   const { config, credentials } = await loadConfigOrFail();
   const { apiBaseUrl, storeId } = config;
@@ -60,6 +122,7 @@ export const dev = async () => {
   const builtTheme = await isBuiltTheme();
   const rootDir = builtTheme ? getDistDir() : process.cwd();
   let buildCleanup = null;
+  let localPreviewServer = null;
 
   // For built themes, run the build first (with watch mode)
   if (builtTheme) {
@@ -71,151 +134,178 @@ export const dev = async () => {
     buildCleanup = buildResult.cleanup;
   }
 
-  const existingPreviewsResult = await listPreviews(
+  // Resolve preview via shared interactive picker
+  const previewKey = await resolvePreviewKeyInteractively({ config, credentials });
+
+  // Fetch preview to get hostname for local proxy
+  const previewResult = await fetchPreviewDetails(
     apiBaseUrl,
     apiKey,
     storeId,
+    previewKey,
   );
-  if (!existingPreviewsResult.ok) {
-    p.log.error(existingPreviewsResult.error);
+  if (!previewResult.ok) {
+    p.log.error(`Preview ${previewKey} not found.`);
     process.exit(1);
   }
 
-  let previewKey =
-    resolveActivePreview(existingPreviewsResult.data, config.previewKey)
-      ?.previewKey ?? config.previewKey;
-  let previewUrl;
+  const previewHostname = previewResult.data.preview.previewHostname;
+  const previewUrl = previewResult.data.url;
 
-  if (!previewKey) {
-    // ── Create preview and do initial upload ─────────────────────────────────
-    const spinner = p.spinner();
-    spinner.start("No active preview found. Creating one...");
+  const spinner = p.spinner();
+  spinner.start("Compressing files...");
 
-    const result = await createPreview(apiBaseUrl, apiKey, storeId, "Dev");
-    if (!result.ok) {
-      spinner.stop("Failed to create preview.", 1);
-      p.log.error(result.error);
-      process.exit(1);
-    }
+  const uploadResult = await pushPreparedDirectoryToPreview({
+    apiBaseUrl,
+    apiKey,
+    storeId,
+    previewKey,
+    rootDir,
+    spinner,
+    compressMessage: "Compressing files...",
+    retryMessage: (result, nextAttempt) =>
+      `Initial push failed. Retrying ${nextAttempt}/${RETRY_ATTEMPTS}... ${result.error}`,
+  });
 
-    previewKey = result.data.previewKey;
-    previewUrl = buildPreviewUrl(apiBaseUrl, result.data.previewHostname);
-    await writeConfig({ ...config, previewKey });
+  if (!uploadResult.ok) {
+    spinner.stop("Initial push failed.", 1);
+    p.log.error(uploadResult.error);
+    process.exit(1);
+  }
 
-    spinner.message("Uploading initial files...");
-    const zipBuffer = await createZipFromDirectory(rootDir);
-    const uploadResult = await uploadPreviewZip(
+  try {
+    localPreviewServer = await startLocalPreviewServer({
       apiBaseUrl,
-      apiKey,
-      storeId,
-      previewKey,
-      zipBuffer,
-    );
-
-    if (!uploadResult.ok) {
-      spinner.stop("Failed to upload files.", 1);
-      p.log.error(uploadResult.error);
-      process.exit(1);
-    }
-
-    spinner.stop(`Preview ready: ${previewUrl}`);
-  } else {
-    // ── Verify existing preview still exists ─────────────────────────────────
-    const spinner = p.spinner();
-    spinner.start("Connecting to preview...");
-
-    const listResult = await listPreviews(apiBaseUrl, apiKey, storeId);
-    if (!listResult.ok) {
-      spinner.stop("Failed to connect.", 1);
-      p.log.error(listResult.error);
-      process.exit(1);
-    }
-
-    const existing = resolveActivePreview(listResult.data, previewKey);
-    if (!existing) {
-      spinner.stop("Could not determine the active preview.", 1);
-      p.log.error(
-        listResult.data.length === 0
-          ? "No previews found for this store. A new preview will be created if you clear the local config and run tiendu dev again."
-          : "Run tiendu preview list and then set or recreate the preview.",
-      );
-      process.exit(1);
-    }
-
-    previewKey = existing.previewKey;
-    if (config.previewKey !== previewKey) {
-      await writeConfig({ ...config, previewKey });
-    }
+      previewHostname,
+    });
+  } catch (error) {
+    p.log.warn(`Could not start local live preview: ${error.message}`);
+  }
 
-    previewUrl = buildPreviewUrl(apiBaseUrl, existing.previewHostname);
-    spinner.stop(`Preview: ${previewUrl}`);
+  spinner.stop(`Preview ready (${previewKey}).`);
+  if (localPreviewServer) {
+    p.log.message(`Local live preview: ${localPreviewServer.url}`);
   }
+  p.log.message(`Sharable preview: ${previewUrl}`);
 
-  p.log.message("Watching for changes — press Ctrl+C to stop.");
+  p.log.message("Watching for changes \u2014 press Ctrl+C to stop.");
 
   // ── File watcher ──────────────────────────────────────────────────────────
   /** @type {Map<string, NodeJS.Timeout>} */
   const debounceMap = new Map();
+  const inFlightPaths = new Set();
+  const pendingResyncPaths = new Set();
   const DEBOUNCE_MS = 300;
 
-  const watcher = watch(rootDir, { recursive: true }, (eventType, filename) => {
-    if (!filename) return;
-    if (hasDotfileSegment(filename)) return;
-
-    const relativePath = filename.split(path.sep).join("/");
-    const existing = debounceMap.get(relativePath);
-    if (existing) clearTimeout(existing);
+  const queueSync = (relativePath) => {
+    const existingTimer = debounceMap.get(relativePath);
+    if (existingTimer) clearTimeout(existingTimer);
 
-    const timer = setTimeout(async () => {
+    const timer = setTimeout(() => {
       debounceMap.delete(relativePath);
-      const absolutePath = path.join(rootDir, filename);
-
-      try {
-        const fileStat = await stat(absolutePath).catch(() => null);
-
-        if (!fileStat || !fileStat.isFile()) {
-          if (!fileStat) {
-            console.log(`✕ ${relativePath}`);
-            const result = await deletePreviewFile(
-              apiBaseUrl,
-              apiKey,
-              storeId,
-              previewKey,
-              relativePath,
-            );
-            if (!result.ok) {
-              p.log.warn(`     Failed to delete: ${result.error}`);
-            }
+      void syncPath(relativePath);
+    }, DEBOUNCE_MS);
+
+    debounceMap.set(relativePath, timer);
+  };
+
+  const syncPath = async (relativePath) => {
+    if (inFlightPaths.has(relativePath)) {
+      pendingResyncPaths.add(relativePath);
+      return;
+    }
+
+    inFlightPaths.add(relativePath);
+
+    try {
+      const absolutePath = path.join(rootDir, relativePath);
+      const fileStat = await stat(absolutePath).catch(() => null);
+
+      if (!fileStat || !fileStat.isFile()) {
+        if (!fileStat) {
+          console.log(`\u2715 ${relativePath}`);
+          const result = await deleteFileWithRetries(
+            apiBaseUrl,
+            apiKey,
+            storeId,
+            previewKey,
+            relativePath,
+            async (_, nextAttempt) => {
+              p.log.warn(
+                `     Retry delete ${relativePath} (${nextAttempt}/${RETRY_ATTEMPTS})`,
+              );
+            },
+          );
+
+          if (!result.ok) {
+            p.log.warn(`     Failed to delete after ${RETRY_ATTEMPTS} attempts: ${result.error}`);
+          } else {
+            localPreviewServer?.notifyReload();
           }
-          return;
         }
 
-        console.log(`↑ ${relativePath}`);
-        const content = await readFile(absolutePath);
-        const result = await uploadPreviewFileMultipart(
-          apiBaseUrl,
-          apiKey,
-          storeId,
-          previewKey,
-          relativePath,
-          content,
+        return;
+      }
+
+      console.log(`\u2191 ${relativePath}`);
+      if (fileStat.size > MAX_SYNC_FILE_SIZE_BYTES) {
+        p.log.warn(
+          `     Skipping ${relativePath}: file is ${(fileStat.size / (1024 * 1024)).toFixed(1)} MB (limit ${(MAX_SYNC_FILE_SIZE_BYTES / (1024 * 1024)).toFixed(0)} MB).`,
         );
+        return;
+      }
 
-        if (!result.ok) {
-          p.log.warn(`     Failed to upload: ${result.error}`);
-        }
-      } catch (error) {
-        p.log.warn(`     Error processing ${relativePath}: ${error.message}`);
+      const content = await readFile(absolutePath);
+      const result = await uploadFileWithRetries(
+        apiBaseUrl,
+        apiKey,
+        storeId,
+        previewKey,
+        relativePath,
+        content,
+        async (_, nextAttempt) => {
+          p.log.warn(
+            `     Retry upload ${relativePath} (${nextAttempt}/${RETRY_ATTEMPTS})`,
+          );
+        },
+      );
+
+      if (!result.ok) {
+        p.log.warn(`     Failed to upload after ${RETRY_ATTEMPTS} attempts: ${result.error}`);
+      } else {
+        localPreviewServer?.notifyReload();
       }
-    }, DEBOUNCE_MS);
+    } catch (error) {
+      p.log.warn(`     Error processing ${relativePath}: ${error.message}`);
+    } finally {
+      inFlightPaths.delete(relativePath);
 
-    debounceMap.set(relativePath, timer);
+      if (pendingResyncPaths.delete(relativePath)) {
+        queueSync(relativePath);
+      }
+    }
+  };
+
+  const watcher = watch(rootDir, { recursive: true }, (eventType, filename) => {
+    if (!filename) return;
+    if (hasDotfileSegment(filename)) return;
+    if (shouldIgnoreWatchedPath(filename, builtTheme)) return;
+
+    const relativePath = filename.split(path.sep).join("/");
+    queueSync(relativePath);
   });
 
+  let cleanedUp = false;
   const cleanup = async () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+
     watcher.close();
     for (const timer of debounceMap.values()) clearTimeout(timer);
-    if (buildCleanup) await buildCleanup();
+
+    await runCleanupStep("Local preview shutdown", () => localPreviewServer?.close());
+    await runCleanupStep("Build watcher shutdown", buildCleanup);
+
     p.outro("Dev mode stopped.");
     process.exit(0);
   };

package/lib/fs-utils.mjs

@@ -0,0 +1,35 @@
+import { access, readdir } from "node:fs/promises";
+import path from "node:path";
+
+export const isDotfile = (name) => name.startsWith(".");
+
+export const fileExists = async (filePath) => {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const listFilesRecursive = async (absoluteDir) => {
+  const entries = await readdir(absoluteDir, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    if (isDotfile(entry.name)) continue;
+
+    const absolutePath = path.join(absoluteDir, entry.name);
+
+    if (entry.isDirectory()) {
+      files.push(...(await listFilesRecursive(absolutePath)));
+      continue;
+    }
+
+    if (entry.isFile()) {
+      files.push(absolutePath);
+    }
+  }
+
+  return files.sort((left, right) => left.localeCompare(right));
+};