tiendu 0.1.2 → 0.2.0

package/bin/tiendu.js

@@ -11,26 +11,31 @@ import {
   previewDelete,
   previewOpen,
 } from "../lib/preview.mjs";
+import { checkForUpdates } from "../lib/update-check.mjs";
 
 const HELP = `
-tiendu — CLI para desarrollar temas de Tiendu
-
-Uso:
-  tiendu init                Inicializar un tema en el directorio actual
-  tiendu pull                Descargar el tema live desde Tiendu
-  tiendu push                Subir archivos locales al preview activo (ZIP)
-  tiendu dev                 Modo desarrollo: watch + sync automático
-  tiendu publish             Publicar el preview activo al storefront live
-
-  tiendu preview create      Crear un preview remoto
-  tiendu preview list        Listar previews de la tienda
-  tiendu preview delete      Eliminar el preview activo
-  tiendu preview open        Abrir la URL del preview en el navegador
-
-  tiendu help                Mostrar esta ayuda
-
-Opciones:
-  --help, -h                 Mostrar esta ayuda
+tiendu — Tiendu theme development CLI
+
+Usage:
+  tiendu init [dir]          Set up a theme project (optionally in a new directory)
+  tiendu pull                Download the live theme from your store
+  tiendu push                Upload local files to the active preview (full replace)
+  tiendu dev                 Start dev mode: auto-sync changes to a live preview URL
+  tiendu publish             Publish the active preview to the live storefront
+
+  tiendu preview create      Create a new remote preview
+  tiendu preview list        List previews for your store
+  tiendu preview delete      Delete the active preview
+  tiendu preview open        Open the preview URL in your browser
+
+  tiendu help                Show this help message
+
+Typical workflow:
+  tiendu init my-store       Set up a new project in ./my-store
+  cd my-store
+  tiendu pull                Download the current live theme
+  tiendu dev                 Edit locally — preview updates in real time
+  tiendu publish             Ship to the live storefront when ready
 `;
 
 const main = async () => {
@@ -38,6 +43,9 @@ const main = async () => {
   const command = args[0];
   const subcommand = args[1];
 
+  // Check for updates at most once per day (non-blocking)
+  await checkForUpdates();
+
   if (
     !command ||
     command === "help" ||
@@ -49,7 +57,7 @@ const main = async () => {
   }
 
   if (command === "init") {
-    await init();
+    await init(args[1]); // optional directory name
     return;
   }
 
@@ -75,32 +83,28 @@ const main = async () => {
 
   if (command === "preview") {
     if (subcommand === "create") {
-      const name = args[2];
-      await previewCreate(name);
+      await previewCreate(args[2]);
       return;
     }
-
     if (subcommand === "list") {
       await previewList();
       return;
     }
-
     if (subcommand === "delete") {
       await previewDelete();
       return;
     }
-
     if (subcommand === "open") {
       await previewOpen();
       return;
     }
 
-    console.error(`Subcomando desconocido: preview ${subcommand ?? "(vacío)"}`);
+    console.error(`Unknown subcommand: preview ${subcommand ?? "(none)"}`);
     console.log(HELP.trim());
     process.exit(1);
   }
 
-  console.error(`Comando desconocido: ${command}`);
+  console.error(`Unknown command: ${command}`);
   console.log(HELP.trim());
   process.exit(1);
 };

package/lib/api.mjs

@@ -43,21 +43,16 @@ const checkAuthErrors = (response) => {
 };
 
 /**
- * Validate API key and store access with a HEAD request to the download endpoint.
+ * Fetch all stores accessible by the current API key.
+ * Also serves as API key validation — 401/403 means invalid key.
  *
  * @param {string} apiBaseUrl
  * @param {string} apiKey
- * @param {number} storeId
- * @returns {Promise<{ ok: true, data: { name: string } } | { ok: false, error: string }>}
+ * @returns {Promise<{ ok: true, data: Array<{ id: number, name: string, hostname: string }> } | { ok: false, error: string }>}
  */
-export const fetchStoreInfo = async (apiBaseUrl, apiKey, storeId) => {
+export const fetchUserStores = async (apiBaseUrl, apiKey) => {
   try {
-    const response = await apiFetch(
-      apiBaseUrl,
-      apiKey,
-      `/api/admin/stores/${storeId}/code/download`,
-      { method: "HEAD" },
-    );
+    const response = await apiFetch(apiBaseUrl, apiKey, `/api/v2/stores`);
 
     const authError = checkAuthErrors(response);
     if (authError) return authError;
@@ -69,7 +64,11 @@ export const fetchStoreInfo = async (apiBaseUrl, apiKey, storeId) => {
       };
     }
 
-    return { ok: true, data: { name: `Tienda #${storeId}` } };
+    const stores = await response.json();
+    return {
+      ok: true,
+      data: Array.isArray(stores) ? stores : [],
+    };
   } catch (error) {
     return {
       ok: false,

package/lib/config.mjs

@@ -60,15 +60,15 @@ export const writeCredentials = async (credentials) => {
 export const loadConfigOrFail = async () => {
   const config = await readConfig();
   if (!config) {
-    console.error("No se encontró .cli/config.json");
-    console.error('Ejecutá "tiendu init" primero.');
+    console.error("Error: no .cli/config.json found. Run tiendu init first.");
     process.exit(1);
   }
 
   const credentials = await readCredentials();
   if (!credentials) {
-    console.error("No se encontró .cli/credentials.json");
-    console.error('Ejecutá "tiendu init" primero.');
+    console.error(
+      "Error: no .cli/credentials.json found. Run tiendu init first.",
+    );
     process.exit(1);
   }
 

package/lib/dev.mjs

@@ -1,39 +1,27 @@
 import { watch } from "node:fs";
-import { readFile, stat } from "node:fs/promises";
+import { readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
+import * as p from "@clack/prompts";
+import { zipSync } from "fflate";
 import { loadConfigOrFail, writeConfig } from "./config.mjs";
 import { createPreview, listPreviews } from "./preview.mjs";
 import {
-  uploadPreviewFileMultipart,
   deletePreviewFile,
+  uploadPreviewFileMultipart,
   uploadPreviewZip,
 } from "./api.mjs";
-import { readdir } from "node:fs/promises";
-import { zipSync } from "fflate";
 
 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}` : ""}/`;
 };
 
-/**
- * Check if a relative path contains any dotfile segments.
- * @param {string} relativePath
- * @returns {boolean}
- */
-const hasDotfileSegment = (relativePath) => {
-  const segments = relativePath.split(path.sep);
-  return segments.some((s) => isDotfile(s));
-};
+const hasDotfileSegment = (relativePath) =>
+  relativePath.split(path.sep).some(isDotfile);
 
-/**
- * Recursively list all files, skipping dotfiles.
- * @param {string} rootDir
- * @param {string} currentDir
- * @returns {Promise<string[]>}
- */
 const listAllFiles = async (rootDir, currentDir) => {
   const entries = await readdir(currentDir, { withFileTypes: true });
   const files = [];
@@ -41,8 +29,7 @@ const listAllFiles = async (rootDir, currentDir) => {
     if (isDotfile(entry.name)) continue;
     const abs = path.join(currentDir, entry.name);
     if (entry.isDirectory()) {
-      const nested = await listAllFiles(rootDir, abs);
-      files.push(...nested);
+      files.push(...(await listAllFiles(rootDir, abs)));
     } else if (entry.isFile()) {
       files.push(abs);
     }
@@ -50,19 +37,13 @@ const listAllFiles = async (rootDir, currentDir) => {
   return files;
 };
 
-/**
- * Create a zip buffer from the current directory, skipping dotfiles.
- * @param {string} rootDir
- * @returns {Promise<Buffer>}
- */
 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("/");
-    const buf = await readFile(abs);
-    entries[rel] = new Uint8Array(buf);
+    entries[rel] = new Uint8Array(await readFile(abs));
   }
   return Buffer.from(zipSync(entries, { level: 6 }));
 };
@@ -74,28 +55,25 @@ export const dev = async () => {
   const rootDir = process.cwd();
 
   let previewKey = config.previewKey;
+  let previewUrl;
 
-  // Ensure a preview exists
   if (!previewKey) {
-    console.log("");
-    console.log("No hay preview activo. Creando uno...");
+    // ── Create preview and do initial upload ─────────────────────────────────
+    const spinner = p.spinner();
+    spinner.start("No active preview found. Creating one...");
 
     const result = await createPreview(apiBaseUrl, apiKey, storeId, "Dev");
     if (!result.ok) {
-      console.error(`Error: ${result.error}`);
+      spinner.stop("Failed to create preview.", 1);
+      p.log.error(result.error);
       process.exit(1);
     }
 
     previewKey = result.data.previewKey;
+    previewUrl = buildPreviewUrl(apiBaseUrl, result.data.previewHostname);
     await writeConfig({ ...config, previewKey });
 
-    console.log(`Preview creado: ${previewKey}`);
-    console.log(
-      `URL: ${buildPreviewUrl(apiBaseUrl, result.data.previewHostname)}`,
-    );
-
-    // Initial push of all files
-    console.log("Subiendo archivos iniciales...");
+    spinner.message("Uploading initial files...");
     const zipBuffer = await createZipFromDirectory(rootDir);
     const uploadResult = await uploadPreviewZip(
       apiBaseUrl,
@@ -104,67 +82,64 @@ export const dev = async () => {
       previewKey,
       zipBuffer,
     );
+
     if (!uploadResult.ok) {
-      console.error(`Error subiendo archivos: ${uploadResult.error}`);
+      spinner.stop("Failed to upload files.", 1);
+      p.log.error(uploadResult.error);
       process.exit(1);
     }
-    console.log("Archivos subidos.");
+
+    spinner.stop(`Preview ready: ${previewUrl}`);
   } else {
-    // Verify the preview still exists
+    // ── Verify existing preview still exists ─────────────────────────────────
+    const spinner = p.spinner();
+    spinner.start("Connecting to preview...");
+
     const listResult = await listPreviews(apiBaseUrl, apiKey, storeId);
     if (!listResult.ok) {
-      console.error(`Error: ${listResult.error}`);
+      spinner.stop("Failed to connect.", 1);
+      p.log.error(listResult.error);
       process.exit(1);
     }
-    const existing = listResult.data.find((p) => p.previewKey === previewKey);
+
+    const existing = listResult.data.find((pr) => pr.previewKey === previewKey);
     if (!existing) {
-      console.error(
-        `El preview ${previewKey} ya no existe. Eliminá la config con: tiendu preview delete`,
+      spinner.stop("Preview no longer exists on the server.", 1);
+      p.log.error(
+        "Run tiendu preview delete to clean up, then tiendu dev again.",
       );
       process.exit(1);
     }
-    console.log("");
-    console.log(`Preview activo: ${previewKey}`);
-    console.log(
-      `URL: ${buildPreviewUrl(apiBaseUrl, existing.previewHostname)}`,
-    );
+
+    previewUrl = buildPreviewUrl(apiBaseUrl, existing.previewHostname);
+    spinner.stop(`Preview: ${previewUrl}`);
   }
 
-  console.log("");
-  console.log("Observando cambios... (Ctrl+C para salir)");
-  console.log("");
+  p.log.message("Watching for changes — press Ctrl+C to stop.\n");
 
-  // Debounce map: relativePath -> timeout
+  // ── File watcher ──────────────────────────────────────────────────────────
   /** @type {Map<string, NodeJS.Timeout>} */
   const debounceMap = new Map();
   const DEBOUNCE_MS = 300;
 
   const watcher = watch(rootDir, { recursive: true }, (eventType, filename) => {
     if (!filename) return;
-
-    // Skip dotfiles
     if (hasDotfileSegment(filename)) return;
 
-    // Normalize to posix path
     const relativePath = filename.split(path.sep).join("/");
-
-    // Clear existing debounce timer
     const existing = debounceMap.get(relativePath);
     if (existing) clearTimeout(existing);
 
-    // Set new debounce timer
     const timer = setTimeout(async () => {
       debounceMap.delete(relativePath);
-
       const absolutePath = path.join(rootDir, filename);
 
       try {
         const fileStat = await stat(absolutePath).catch(() => null);
 
         if (!fileStat || !fileStat.isFile()) {
-          // File was deleted or is a directory
           if (!fileStat) {
-            console.log(`  ✕ ${relativePath}`);
+            p.log.message(`  ✕  ${relativePath}`);
             const result = await deletePreviewFile(
               apiBaseUrl,
               apiKey,
@@ -173,16 +148,14 @@ export const dev = async () => {
               relativePath,
             );
             if (!result.ok) {
-              console.error(`    Error: ${result.error}`);
+              p.log.warn(`     Failed to delete: ${result.error}`);
             }
           }
           return;
         }
 
-        // File was created or modified
+        p.log.message(`  ↑  ${relativePath}`);
         const content = await readFile(absolutePath);
-        console.log(`  ↑ ${relativePath}`);
-
         const result = await uploadPreviewFileMultipart(
           apiBaseUrl,
           apiKey,
@@ -193,30 +166,25 @@ export const dev = async () => {
         );
 
         if (!result.ok) {
-          console.error(`    Error: ${result.error}`);
+          p.log.warn(`     Failed to upload: ${result.error}`);
         }
       } catch (error) {
-        console.error(`  Error procesando ${relativePath}: ${error.message}`);
+        p.log.warn(`     Error processing ${relativePath}: ${error.message}`);
       }
     }, DEBOUNCE_MS);
 
     debounceMap.set(relativePath, timer);
   });
 
-  // Handle graceful shutdown
   const cleanup = () => {
     watcher.close();
-    for (const timer of debounceMap.values()) {
-      clearTimeout(timer);
-    }
-    console.log("");
-    console.log("Dev mode finalizado.");
+    for (const timer of debounceMap.values()) clearTimeout(timer);
+    p.outro("Dev mode stopped.");
     process.exit(0);
   };
 
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
 
-  // Keep process alive
   await new Promise(() => {});
 };

package/lib/init.mjs

@@ -1,97 +1,162 @@
-import * as readline from "node:readline/promises";
-import { stdin, stdout } from "node:process";
+import { mkdir, access } from "node:fs/promises";
+import path from "node:path";
+import * as p from "@clack/prompts";
 import {
   readConfig,
   readCredentials,
   writeConfig,
   writeCredentials,
 } from "./config.mjs";
-import { fetchStoreInfo } from "./api.mjs";
+import { fetchUserStores } from "./api.mjs";
 
-export const init = async () => {
+/** @param {string} url */
+const normalizeBaseUrl = (url) => (url.endsWith("/") ? url.slice(0, -1) : url);
+
+/**
+ * @param {string | undefined} dirArg  optional directory name passed as CLI arg
+ */
+export const init = async (dirArg) => {
+  // ─── Resolve working directory ────────────────────────────────────────────
+  let workDir = process.cwd();
+
+  if (dirArg) {
+    const targetDir = path.resolve(process.cwd(), dirArg);
+
+    // Fail clearly if the directory already exists
+    try {
+      await access(targetDir);
+      // access succeeded → it exists
+      p.intro("Tiendu CLI — Setup");
+      p.cancel(`Directory "${dirArg}" already exists.`);
+      process.exit(1);
+    } catch {
+      // access failed → doesn't exist, safe to create
+    }
+
+    await mkdir(targetDir, { recursive: true });
+    workDir = targetDir;
+
+    // Change cwd so config is written inside the new directory
+    process.chdir(workDir);
+  }
+
+  // Re-read config after potential chdir
   const existingConfig = await readConfig();
   const existingCredentials = await readCredentials();
 
-  const rl = readline.createInterface({ input: stdin, output: stdout });
+  p.intro("Tiendu CLI — Setup");
 
-  try {
-    console.log("");
-    console.log("Tiendu CLI — Inicialización");
-    console.log("===========================");
-    console.log("");
+  // ─── API Key ──────────────────────────────────────────────────────────────
+  const apiKeyDefault = existingCredentials?.apiKey ?? "";
 
-    // API key
-    const defaultApiKey = existingCredentials?.apiKey ?? "";
-    const apiKeyPrompt = defaultApiKey
-      ? `API Key [${maskApiKey(defaultApiKey)}]: `
-      : "API Key: ";
-    const apiKeyInput = (await rl.question(apiKeyPrompt)).trim();
-    const apiKey = apiKeyInput || defaultApiKey;
+  const apiKeyInput = await p.password({
+    message: "API Key",
+    mask: "*",
+    validate: (value) => {
+      const resolved = (value ?? "").trim() || apiKeyDefault;
+      if (!resolved) return "API Key is required.";
+    },
+  });
 
-    if (!apiKey) {
-      console.error("La API Key es requerida.");
-      process.exit(1);
-    }
+  if (p.isCancel(apiKeyInput)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
 
-    // API base URL
-    const defaultBaseUrl = existingConfig?.apiBaseUrl ?? "https://tiendu.uy";
-    const baseUrlInput = (
-      await rl.question(`URL base de la API [${defaultBaseUrl}]: `)
-    ).trim();
-    const apiBaseUrl = normalizeBaseUrl(baseUrlInput || defaultBaseUrl);
-
-    // Store ID
-    const defaultStoreId = existingConfig?.storeId ?? "";
-    const storeIdPrompt = defaultStoreId
-      ? `Store ID [${defaultStoreId}]: `
-      : "Store ID: ";
-    const storeIdInput = (await rl.question(storeIdPrompt)).trim();
-    const storeIdRaw = storeIdInput || String(defaultStoreId);
-    const storeId = Number(storeIdRaw);
-
-    if (!Number.isInteger(storeId) || storeId <= 0) {
-      console.error("El Store ID debe ser un número entero positivo.");
-      process.exit(1);
-    }
+  const apiKey = (apiKeyInput ?? "").trim() || apiKeyDefault;
 
-    // Validate credentials against the server
-    console.log("");
-    console.log("Verificando credenciales...");
+  // ─── API Base URL ─────────────────────────────────────────────────────────
+  const baseUrlDefault = existingConfig?.apiBaseUrl ?? "https://tiendu.uy";
 
-    const storeInfo = await fetchStoreInfo(apiBaseUrl, apiKey, storeId);
-    if (!storeInfo.ok) {
-      console.error(`Error: ${storeInfo.error}`);
-      process.exit(1);
+  const baseUrlInput = await p.text({
+    message: "API base URL",
+    placeholder: baseUrlDefault,
+    defaultValue: baseUrlDefault,
+    validate: (value) => {
+      const resolved = (value ?? "").trim() || baseUrlDefault;
+      try {
+        new URL(resolved);
+      } catch {
+        return "Invalid URL.";
+      }
+    },
+  });
+
+  if (p.isCancel(baseUrlInput)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+
+  const apiBaseUrl = normalizeBaseUrl(
+    (baseUrlInput ?? "").trim() || baseUrlDefault,
+  );
+
+  // ─── Fetch stores (validates API key implicitly) ───────────────────────────
+  const spinner = p.spinner();
+  spinner.start("Verifying credentials...");
+
+  const storesResult = await fetchUserStores(apiBaseUrl, apiKey);
+
+  if (!storesResult.ok) {
+    spinner.stop("Failed to verify credentials.", 1);
+    p.cancel(storesResult.error);
+    process.exit(1);
+  }
+
+  const stores = storesResult.data;
+
+  if (stores.length === 0) {
+    spinner.stop("No stores found.", 1);
+    p.cancel("Your API Key does not have access to any store.");
+    process.exit(1);
+  }
+
+  spinner.stop(
+    `${stores.length} store${stores.length === 1 ? "" : "s"} found.`,
+  );
+
+  // ─── Select store ─────────────────────────────────────────────────────────
+  let storeId;
+
+  if (stores.length === 1) {
+    storeId = stores[0].id;
+    p.log.info(`Store: ${stores[0].name} (ID: ${storeId})`);
+  } else {
+    const selectedId = await p.select({
+      message: "Select a store",
+      options: stores.map((store) => ({
+        value: store.id,
+        label: store.name,
+        hint: `ID: ${store.id}`,
+      })),
+      initialValue: existingConfig?.storeId ?? stores[0].id,
+    });
+
+    if (p.isCancel(selectedId)) {
+      p.cancel("Setup cancelled.");
+      process.exit(0);
     }
 
-    console.log(`Tienda: ${storeInfo.data.name} (ID: ${storeId})`);
-    console.log("");
-
-    // Save
-    await writeConfig({ storeId, apiBaseUrl });
-    await writeCredentials({ apiKey });
-
-    console.log("Configuración guardada en .cli/");
-    console.log("");
-    console.log('Próximo paso: ejecutá "tiendu pull" para descargar el tema.');
-    console.log("");
-    console.log("Nota: habilitá el modo dev en la plataforma Tiendu");
-    console.log(
-      "(Ajustes > General) para que los datos del preview se muestren correctamente.",
-    );
-    console.log("");
-  } finally {
-    rl.close();
+    storeId = selectedId;
   }
-};
 
-/** @param {string} key */
-const maskApiKey = (key) => {
-  if (key.length <= 8) return "****";
-  return key.slice(0, 4) + "..." + key.slice(-4);
-};
+  // ─── Save ─────────────────────────────────────────────────────────────────
+  await writeConfig({ storeId, apiBaseUrl });
+  await writeCredentials({ apiKey });
 
-/** @param {string} url */
-const normalizeBaseUrl = (url) => {
-  return url.endsWith("/") ? url.slice(0, -1) : url;
+  const nextSteps = dirArg
+    ? [`cd ${dirArg}`, `tiendu pull  # download the current live theme`]
+    : [`tiendu pull  # download the current live theme`];
+
+  p.note(
+    [
+      ...nextSteps,
+      "",
+      "Tip: enable Dev Mode in the Tiendu platform",
+      "(Settings → General) for preview data to load correctly.",
+    ].join("\n"),
+    "Next steps",
+  );
+
+  p.outro("Configuration saved to .cli/");
 };

package/lib/preview.mjs

@@ -1,3 +1,4 @@
+import * as p from "@clack/prompts";
 import { loadConfigOrFail, writeConfig } from "./config.mjs";
 import { apiFetch } from "./api.mjs";
 
@@ -30,7 +31,7 @@ export const createPreview = async (apiBaseUrl, apiKey, storeId, name) => {
       const body = await response.json().catch(() => ({}));
       const message =
         body?.error?.message ??
-        "Ya existe un preview para esta tienda. Eliminalo antes de crear uno nuevo.";
+        "A preview already exists for this store. Delete it first with: tiendu preview delete";
       return { ok: false, error: message };
     }
 
@@ -38,17 +39,14 @@ export const createPreview = async (apiBaseUrl, apiKey, storeId, name) => {
       const body = await response.text().catch(() => "");
       return {
         ok: false,
-        error: `Error del servidor: ${response.status}${body ? ` — ${body}` : ""}`,
+        error: `Server error: ${response.status}${body ? ` — ${body}` : ""}`,
       };
     }
 
     const preview = await response.json();
     return { ok: true, data: preview };
   } catch (error) {
-    return {
-      ok: false,
-      error: `No se pudo crear el preview: ${error.message}`,
-    };
+    return { ok: false, error: `Could not create preview: ${error.message}` };
   }
 };
 
@@ -65,16 +63,13 @@ export const listPreviews = async (apiBaseUrl, apiKey, storeId) => {
       apiKey,
       `/api/v2/stores/${storeId}/theme-previews`,
     );
-
     if (!response.ok) {
-      return { ok: false, error: `Error del servidor: ${response.status}` };
+      return { ok: false, error: `Server error: ${response.status}` };
     }
-
     const body = await response.json();
-    const previews = body?.previews ?? [];
-    return { ok: true, data: previews };
+    return { ok: true, data: body?.previews ?? [] };
   } catch (error) {
-    return { ok: false, error: `No se pudo listar previews: ${error.message}` };
+    return { ok: false, error: `Could not list previews: ${error.message}` };
   }
 };
 
@@ -96,25 +91,18 @@ export const deletePreview = async (
       apiBaseUrl,
       apiKey,
       `/api/v2/stores/${storeId}/theme-previews/${previewKey}`,
-      {
-        method: "DELETE",
-      },
+      { method: "DELETE" },
     );
-
     if (!response.ok) {
       const body = await response.text().catch(() => "");
       return {
         ok: false,
-        error: `Error del servidor: ${response.status}${body ? ` — ${body}` : ""}`,
+        error: `Server error: ${response.status}${body ? ` — ${body}` : ""}`,
       };
     }
-
     return { ok: true };
   } catch (error) {
-    return {
-      ok: false,
-      error: `No se pudo eliminar el preview: ${error.message}`,
-    };
+    return { ok: false, error: `Could not delete preview: ${error.message}` };
   }
 };
 
@@ -136,25 +124,18 @@ export const publishPreview = async (
       apiBaseUrl,
       apiKey,
       `/api/v2/stores/${storeId}/theme-previews/${previewKey}/publish`,
-      {
-        method: "POST",
-      },
+      { method: "POST" },
     );
-
     if (!response.ok) {
       const body = await response.text().catch(() => "");
       return {
         ok: false,
-        error: `Error del servidor: ${response.status}${body ? ` — ${body}` : ""}`,
+        error: `Server error: ${response.status}${body ? ` — ${body}` : ""}`,
       };
     }
-
     return { ok: true };
   } catch (error) {
-    return {
-      ok: false,
-      error: `No se pudo publicar el preview: ${error.message}`,
-    };
+    return { ok: false, error: `Could not publish preview: ${error.message}` };
   }
 };
 
@@ -165,8 +146,8 @@ export const publishPreview = async (
 export const previewCreate = async (name) => {
   const { config, credentials } = await loadConfigOrFail();
 
-  console.log("");
-  console.log("Creando preview...");
+  const spinner = p.spinner();
+  spinner.start("Creating preview...");
 
   const result = await createPreview(
     config.apiBaseUrl,
@@ -176,24 +157,24 @@ export const previewCreate = async (name) => {
   );
 
   if (!result.ok) {
-    console.error(`Error: ${result.error}`);
+    spinner.stop("Failed to create preview.", 1);
+    p.log.error(result.error);
     process.exit(1);
   }
 
   const preview = result.data;
-  console.log(`Preview creado: ${preview.previewKey}`);
-  console.log(
-    `URL: ${buildPreviewUrl(config.apiBaseUrl, preview.previewHostname)}`,
-  );
-  console.log("");
+  const url = buildPreviewUrl(config.apiBaseUrl, preview.previewHostname);
+  spinner.stop(`Preview created: ${url}`);
 
-  // Save preview key to config
   await writeConfig({ ...config, previewKey: preview.previewKey });
 };
 
 export const previewList = async () => {
   const { config, credentials } = await loadConfigOrFail();
 
+  const spinner = p.spinner();
+  spinner.start("Fetching previews...");
+
   const result = await listPreviews(
     config.apiBaseUrl,
     credentials.apiKey,
@@ -201,36 +182,46 @@ export const previewList = async () => {
   );
 
   if (!result.ok) {
-    console.error(`Error: ${result.error}`);
+    spinner.stop("Failed to fetch previews.", 1);
+    p.log.error(result.error);
     process.exit(1);
   }
 
-  console.log("");
   if (result.data.length === 0) {
-    console.log("No hay previews para esta tienda.");
-  } else {
-    console.log("Previews:");
-    for (const preview of result.data) {
-      const active =
-        config.previewKey === preview.previewKey ? " (activo)" : "";
-      console.log(
-        `  ${preview.previewKey}  ${preview.name}  ${buildPreviewUrl(config.apiBaseUrl, preview.previewHostname)}${active}`,
-      );
-    }
+    spinner.stop("No previews for this store.");
+    return;
+  }
+
+  spinner.stop(
+    `${result.data.length} preview${result.data.length === 1 ? "" : "s"}:`,
+  );
+
+  for (const preview of result.data) {
+    const active = config.previewKey === preview.previewKey ? " ← active" : "";
+    const url = buildPreviewUrl(config.apiBaseUrl, preview.previewHostname);
+    p.log.message(`  ${preview.name}  ${url}${active}`);
   }
-  console.log("");
 };
 
 export const previewDelete = async () => {
   const { config, credentials } = await loadConfigOrFail();
 
   if (!config.previewKey) {
-    console.error("No hay preview activo. Creá uno con: tiendu preview create");
+    p.log.error("No active preview. Create one with: tiendu preview create");
     process.exit(1);
   }
 
-  console.log("");
-  console.log(`Eliminando preview ${config.previewKey}...`);
+  const confirmed = await p.confirm({
+    message: `Delete preview ${config.previewKey}?`,
+  });
+
+  if (p.isCancel(confirmed) || !confirmed) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+
+  const spinner = p.spinner();
+  spinner.start("Deleting preview...");
 
   const result = await deletePreview(
     config.apiBaseUrl,
@@ -240,28 +231,28 @@ export const previewDelete = async () => {
   );
 
   if (!result.ok) {
-    console.error(`Error: ${result.error}`);
+    spinner.stop("Failed to delete preview.", 1);
+    p.log.error(result.error);
     process.exit(1);
   }
 
-  console.log("Preview eliminado.");
-  console.log("");
+  spinner.stop("Preview deleted.");
 
-  // Remove preview key from config
   const { previewKey, ...rest } = config;
   await writeConfig(rest);
 };
 
 export const previewOpen = async () => {
-  const { config } = await loadConfigOrFail();
+  const { config, credentials } = await loadConfigOrFail();
 
   if (!config.previewKey) {
-    console.error("No hay preview activo. Creá uno con: tiendu preview create");
+    p.log.error("No active preview. Create one with: tiendu preview create");
     process.exit(1);
   }
 
-  // Find the preview to get its hostname
-  const { credentials } = await loadConfigOrFail();
+  const spinner = p.spinner();
+  spinner.start("Fetching preview URL...");
+
   const result = await listPreviews(
     config.apiBaseUrl,
     credentials.apiKey,
@@ -269,26 +260,26 @@ export const previewOpen = async () => {
   );
 
   if (!result.ok) {
-    console.error(`Error: ${result.error}`);
+    spinner.stop("Failed to fetch previews.", 1);
+    p.log.error(result.error);
     process.exit(1);
   }
 
-  const preview = result.data.find((p) => p.previewKey === config.previewKey);
+  const preview = result.data.find((pr) => pr.previewKey === config.previewKey);
   if (!preview) {
-    console.error("El preview activo ya no existe en el servidor.");
+    spinner.stop("Active preview no longer exists on the server.", 1);
+    p.log.error("Run tiendu preview delete to clean up the local config.");
     process.exit(1);
   }
 
   const url = buildPreviewUrl(config.apiBaseUrl, preview.previewHostname);
-  console.log(`Abriendo ${url}...`);
+  spinner.stop(`Opening ${url}`);
 
-  // Open URL in browser
   const { exec } = await import("node:child_process");
-  const platform = process.platform;
   const cmd =
-    platform === "darwin"
+    process.platform === "darwin"
       ? "open"
-      : platform === "win32"
+      : process.platform === "win32"
         ? "start"
         : "xdg-open";
   exec(`${cmd} ${url}`);

package/lib/publish.mjs

@@ -1,3 +1,4 @@
+import * as p from "@clack/prompts";
 import { loadConfigOrFail, writeConfig } from "./config.mjs";
 import { publishPreview } from "./preview.mjs";
 
@@ -5,12 +6,21 @@ export const publish = async () => {
   const { config, credentials } = await loadConfigOrFail();
 
   if (!config.previewKey) {
-    console.error("No hay preview activo. Creá uno con: tiendu preview create");
+    p.log.error("No active preview. Create one with: tiendu preview create");
     process.exit(1);
   }
 
-  console.log("");
-  console.log(`Publicando preview ${config.previewKey} al storefront live...`);
+  const confirmed = await p.confirm({
+    message: `Publish preview ${config.previewKey} to the live storefront?`,
+  });
+
+  if (p.isCancel(confirmed) || !confirmed) {
+    p.cancel("Publish cancelled.");
+    process.exit(0);
+  }
+
+  const spinner = p.spinner();
+  spinner.start("Publishing preview...");
 
   const result = await publishPreview(
     config.apiBaseUrl,
@@ -20,13 +30,13 @@ export const publish = async () => {
   );
 
   if (!result.ok) {
-    console.error(`Error: ${result.error}`);
+    spinner.stop("Publish failed.", 1);
+    p.log.error(result.error);
     process.exit(1);
   }
 
-  console.log("Preview publicado. El storefront live fue actualizado.");
-  console.log("Todos los previews de esta tienda fueron eliminados.");
-  console.log("");
+  spinner.stop("Preview published. Your live storefront has been updated.");
+  p.log.info("All previews for this store have been removed.");
 
   // Remove preview key from config
   const { previewKey, ...rest } = config;

package/lib/pull.mjs

@@ -1,12 +1,20 @@
+import * as p from "@clack/prompts";
 import { loadConfigOrFail } from "./config.mjs";
 import { downloadStorefrontArchive } from "./api.mjs";
 import { extractZip } from "./zip.mjs";
 
+/** @param {number} bytes */
+const formatBytes = (bytes) => {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+};
+
 export const pull = async () => {
   const { config, credentials } = await loadConfigOrFail();
 
-  console.log("");
-  console.log(`Descargando tema de tienda #${config.storeId}...`);
+  const spinner = p.spinner();
+  spinner.start(`Downloading theme from store #${config.storeId}...`);
 
   const result = await downloadStorefrontArchive(
     config.apiBaseUrl,
@@ -15,27 +23,23 @@ export const pull = async () => {
   );
 
   if (!result.ok) {
-    console.error(`Error: ${result.error}`);
+    spinner.stop("Download failed.", 1);
+    p.log.error(result.error);
     process.exit(1);
   }
 
-  console.log(`Archivo ZIP recibido (${formatBytes(result.data.length)})`);
-  console.log("Extrayendo archivos...");
+  spinner.stop(
+    `Archive received (${formatBytes(result.data.length)}). Extracting...`,
+  );
 
   const outputDir = process.cwd();
   const extractedFiles = await extractZip(result.data, outputDir);
 
-  console.log("");
-  console.log(`${extractedFiles.length} archivos extraídos:`);
+  p.log.success(
+    `${extractedFiles.length} file${extractedFiles.length === 1 ? "" : "s"} extracted.`,
+  );
+
   for (const file of extractedFiles) {
-    console.log(`  ${file}`);
+    p.log.message(`  ${file}`);
   }
-  console.log("");
-};
-
-/** @param {number} bytes */
-const formatBytes = (bytes) => {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 };

package/lib/push.mjs

@@ -1,9 +1,17 @@
-import { readdir, readFile, stat } from "node:fs/promises";
+import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
+import * as p from "@clack/prompts";
 import { zipSync } from "fflate";
 import { loadConfigOrFail } from "./config.mjs";
 import { uploadPreviewZip } from "./api.mjs";
 
+/** @param {number} bytes */
+const formatBytes = (bytes) => {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+};
+
 const isDotfile = (name) => name.startsWith(".");
 
 /**
@@ -15,20 +23,15 @@ const isDotfile = (name) => name.startsWith(".");
 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 absolutePath = path.join(currentDir, entry.name);
-
+    const abs = path.join(currentDir, entry.name);
     if (entry.isDirectory()) {
-      const nested = await listAllFiles(rootDir, absolutePath);
-      files.push(...nested);
+      files.push(...(await listAllFiles(rootDir, abs)));
     } else if (entry.isFile()) {
-      files.push(absolutePath);
+      files.push(abs);
     }
   }
-
   return files;
 };
 
@@ -41,16 +44,10 @@ const createZipFromDirectory = async (rootDir) => {
   const absoluteFiles = await listAllFiles(rootDir, rootDir);
   /** @type {Record<string, Uint8Array>} */
   const entries = {};
-
-  for (const absoluteFilePath of absoluteFiles) {
-    const relativePath = path
-      .relative(rootDir, absoluteFilePath)
-      .split(path.sep)
-      .join("/");
-    const fileBuffer = await readFile(absoluteFilePath);
-    entries[relativePath] = new Uint8Array(fileBuffer);
+  for (const abs of absoluteFiles) {
+    const rel = path.relative(rootDir, abs).split(path.sep).join("/");
+    entries[rel] = new Uint8Array(await readFile(abs));
   }
-
   return Buffer.from(zipSync(entries, { level: 6 }));
 };
 
@@ -58,17 +55,18 @@ export const push = async () => {
   const { config, credentials } = await loadConfigOrFail();
 
   if (!config.previewKey) {
-    console.error("No hay preview activo. Creá uno con: tiendu preview create");
+    p.log.error("No active preview. Create one with: tiendu preview create");
     process.exit(1);
   }
 
   const rootDir = process.cwd();
-
-  console.log("");
-  console.log(`Subiendo archivos al preview ${config.previewKey}...`);
+  const spinner = p.spinner();
+  spinner.start("Packing files...");
 
   const zipBuffer = await createZipFromDirectory(rootDir);
-  console.log(`ZIP creado (${formatBytes(zipBuffer.length)})`);
+  spinner.message(
+    `Uploading to preview ${config.previewKey} (${formatBytes(zipBuffer.length)})...`,
+  );
 
   const result = await uploadPreviewZip(
     config.apiBaseUrl,
@@ -79,17 +77,10 @@ export const push = async () => {
   );
 
   if (!result.ok) {
-    console.error(`Error: ${result.error}`);
+    spinner.stop("Upload failed.", 1);
+    p.log.error(result.error);
     process.exit(1);
   }
 
-  console.log("Archivos subidos al preview.");
-  console.log("");
-};
-
-/** @param {number} bytes */
-const formatBytes = (bytes) => {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  spinner.stop("Files uploaded to preview.");
 };

package/lib/update-check.mjs

@@ -0,0 +1,144 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import * as p from "@clack/prompts";
+
+const CONFIG_DIR = ".cli";
+const UPDATE_CHECK_FILE = "update-check.json";
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+const NPM_REGISTRY_URL = "https://registry.npmjs.org/tiendu/latest";
+
+const getUpdateCheckPath = () =>
+  path.resolve(process.cwd(), CONFIG_DIR, UPDATE_CHECK_FILE);
+
+/**
+ * @returns {Promise<{ lastChecked: number, latestVersion: string | null } | null>}
+ */
+const readUpdateCheckState = async () => {
+  try {
+    const raw = await readFile(getUpdateCheckPath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * @param {{ lastChecked: number, latestVersion: string | null }} state
+ */
+const writeUpdateCheckState = async (state) => {
+  try {
+    await mkdir(path.resolve(process.cwd(), CONFIG_DIR), { recursive: true });
+    await writeFile(
+      getUpdateCheckPath(),
+      JSON.stringify(state, null, "\t") + "\n",
+      "utf-8",
+    );
+  } catch {
+    // silently ignore write errors
+  }
+};
+
+/**
+ * @returns {Promise<string | null>} latest version from npm, or null on error
+ */
+const fetchLatestVersion = async () => {
+  try {
+    const res = await fetch(NPM_REGISTRY_URL, {
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * @param {string} a
+ * @param {string} b
+ * @returns {boolean} true if a is strictly older than b
+ */
+const isOlderVersion = (a, b) => {
+  const parse = (v) => v.split(".").map(Number);
+  const [aMajor, aMinor, aPatch] = parse(a);
+  const [bMajor, bMinor, bPatch] = parse(b);
+  if (aMajor !== bMajor) return aMajor < bMajor;
+  if (aMinor !== bMinor) return aMinor < bMinor;
+  return aPatch < bPatch;
+};
+
+/**
+ * Reads local package.json version.
+ * @returns {string}
+ */
+const getCurrentVersion = () => {
+  // Resolved at import time via static path relative to this file
+  return TIENDU_CLI_VERSION;
+};
+
+// This constant is replaced at build time via package.json version
+// We read it dynamically to avoid hardcoding.
+let TIENDU_CLI_VERSION = "0.0.0";
+try {
+  const pkgPath = new URL("../package.json", import.meta.url);
+  const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+  TIENDU_CLI_VERSION = pkg.version ?? "0.0.0";
+} catch {
+  // ignore
+}
+
+/**
+ * Check npm registry for a newer version at most once per day.
+ * Shows a clack note if an update is available.
+ * Does nothing if check fails — never blocks the user.
+ */
+export const checkForUpdates = async () => {
+  const now = Date.now();
+  const state = await readUpdateCheckState();
+
+  // If checked within the last 24h, use cached result
+  if (state && now - state.lastChecked < ONE_DAY_MS) {
+    const currentVersion = TIENDU_CLI_VERSION;
+    if (
+      state.latestVersion &&
+      isOlderVersion(currentVersion, state.latestVersion)
+    ) {
+      showUpdateNote(currentVersion, state.latestVersion);
+    }
+    return;
+  }
+
+  // Fetch latest version (non-blocking — failures are silent)
+  const latestVersion = await fetchLatestVersion();
+
+  await writeUpdateCheckState({ lastChecked: now, latestVersion });
+
+  if (!latestVersion) {
+    // Failed to check — don't show an error, just continue silently
+    return;
+  }
+
+  const currentVersion = TIENDU_CLI_VERSION;
+  if (isOlderVersion(currentVersion, latestVersion)) {
+    showUpdateNote(currentVersion, latestVersion);
+  }
+};
+
+/**
+ * @param {string} current
+ * @param {string} latest
+ */
+const showUpdateNote = (current, latest) => {
+  p.note(
+    [
+      `A new version of Tiendu CLI is available! 🎉`,
+      ``,
+      `  ${current}  →  ${latest}`,
+      ``,
+      `Update by running:`,
+      `  npm install -g tiendu@latest`,
+    ].join("\n"),
+    "Update available",
+  );
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiendu",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "CLI para desarrollar y publicar temas en Tiendu",
   "type": "module",
   "bin": {
@@ -36,6 +36,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@clack/prompts": "^1.1.0",
     "fflate": "^0.8.2"
   }
 }