tiendu 0.1.1

package/lib/api.mjs

@@ -0,0 +1,316 @@
+/**
+ * @param {string} apiBaseUrl
+ * @param {string} apiKey
+ * @param {string} path
+ * @param {{ method?: string, body?: string | Buffer | Uint8Array, contentType?: string }} [options]
+ * @returns {Promise<Response>}
+ */
+export const apiFetch = (apiBaseUrl, apiKey, path, options = {}) => {
+  const url = `${apiBaseUrl}${path}`;
+  /** @type {Record<string, string>} */
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+  };
+
+  if (options.body && typeof options.body === "string") {
+    headers["Content-Type"] = options.contentType ?? "application/json";
+  } else if (options.contentType) {
+    headers["Content-Type"] = options.contentType;
+  }
+
+  return fetch(url, {
+    method: options.method ?? "GET",
+    headers,
+    body: options.body,
+  });
+};
+
+/**
+ * @param {Response} response
+ * @returns {{ ok: false, error: string } | null}
+ */
+const checkAuthErrors = (response) => {
+  if (response.status === 401) {
+    return { ok: false, error: "API Key inválida o sin permisos." };
+  }
+  if (response.status === 403) {
+    return {
+      ok: false,
+      error: "No tenés acceso a esta tienda con esta API Key.",
+    };
+  }
+  return null;
+};
+
+/**
+ * Validate API key and store access with a HEAD request to the download endpoint.
+ *
+ * @param {string} apiBaseUrl
+ * @param {string} apiKey
+ * @param {number} storeId
+ * @returns {Promise<{ ok: true, data: { name: string } } | { ok: false, error: string }>}
+ */
+export const fetchStoreInfo = async (apiBaseUrl, apiKey, storeId) => {
+  try {
+    const response = await apiFetch(
+      apiBaseUrl,
+      apiKey,
+      `/api/admin/stores/${storeId}/code/download`,
+      { method: "HEAD" },
+    );
+
+    const authError = checkAuthErrors(response);
+    if (authError) return authError;
+
+    if (!response.ok) {
+      return {
+        ok: false,
+        error: `Error del servidor: ${response.status} ${response.statusText}`,
+      };
+    }
+
+    return { ok: true, data: { name: `Tienda #${storeId}` } };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `No se pudo conectar a ${apiBaseUrl}: ${error.message}`,
+    };
+  }
+};
+
+/**
+ * Download the storefront archive (zip) as a buffer.
+ *
+ * @param {string} apiBaseUrl
+ * @param {string} apiKey
+ * @param {number} storeId
+ * @returns {Promise<{ ok: true, data: Buffer } | { ok: false, error: string }>}
+ */
+export const downloadStorefrontArchive = async (
+  apiBaseUrl,
+  apiKey,
+  storeId,
+) => {
+  try {
+    const response = await apiFetch(
+      apiBaseUrl,
+      apiKey,
+      `/api/admin/stores/${storeId}/code/download`,
+    );
+
+    const authError = checkAuthErrors(response);
+    if (authError) return authError;
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      return {
+        ok: false,
+        error: `Error del servidor: ${response.status} ${response.statusText}${body ? ` — ${body}` : ""}`,
+      };
+    }
+
+    const arrayBuffer = await response.arrayBuffer();
+    return { ok: true, data: Buffer.from(arrayBuffer) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `No se pudo descargar: ${error.message}`,
+    };
+  }
+};
+
+/**
+ * Upload a zip buffer to a preview, replacing its content.
+ *
+ * @param {string} apiBaseUrl
+ * @param {string} apiKey
+ * @param {number} storeId
+ * @param {string} previewKey
+ * @param {Buffer} zipBuffer
+ * @returns {Promise<{ ok: true } | { ok: false, error: string }>}
+ */
+export const uploadPreviewZip = async (
+  apiBaseUrl,
+  apiKey,
+  storeId,
+  previewKey,
+  zipBuffer,
+) => {
+  try {
+    const response = await apiFetch(
+      apiBaseUrl,
+      apiKey,
+      `/api/admin/stores/${storeId}/theme-previews/${previewKey}/upload`,
+      {
+        method: "POST",
+        body: zipBuffer,
+        contentType: "application/zip",
+      },
+    );
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      return {
+        ok: false,
+        error: `Error del servidor: ${response.status}${body ? ` — ${body}` : ""}`,
+      };
+    }
+
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: `No se pudo subir: ${error.message}` };
+  }
+};
+
+/**
+ * Upload a single file to a preview.
+ *
+ * @param {string} apiBaseUrl
+ * @param {string} apiKey
+ * @param {number} storeId
+ * @param {string} previewKey
+ * @param {string} filePath - relative path within the preview
+ * @param {string} content - file content
+ * @returns {Promise<{ ok: true } | { ok: false, error: string }>}
+ */
+export const uploadPreviewFile = async (
+  apiBaseUrl,
+  apiKey,
+  storeId,
+  previewKey,
+  filePath,
+  content,
+) => {
+  try {
+    const query = new URLSearchParams({ path: filePath }).toString();
+    const response = await apiFetch(
+      apiBaseUrl,
+      apiKey,
+      `/api/v2/stores/${storeId}/theme-previews/${previewKey}/file?${query}`,
+      {
+        method: "PUT",
+        body: JSON.stringify({ content }),
+      },
+    );
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      return {
+        ok: false,
+        error: `Error subiendo ${filePath}: ${response.status}${body ? ` — ${body}` : ""}`,
+      };
+    }
+
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Error subiendo ${filePath}: ${error.message}`,
+    };
+  }
+};
+
+/**
+ * Upload a single file to a preview using multipart form data.
+ * Works for both text and binary files.
+ *
+ * @param {string} apiBaseUrl
+ * @param {string} apiKey
+ * @param {number} storeId
+ * @param {string} previewKey
+ * @param {string} relativePath
+ * @param {Buffer} fileBuffer
+ * @returns {Promise<{ ok: true } | { ok: false, error: string }>}
+ */
+export const uploadPreviewFileMultipart = async (
+  apiBaseUrl,
+  apiKey,
+  storeId,
+  previewKey,
+  relativePath,
+  fileBuffer,
+) => {
+  try {
+    const posixPath = relativePath.replaceAll("\\", "/");
+    const lastSlashIndex = posixPath.lastIndexOf("/");
+    const directory =
+      lastSlashIndex === -1 ? "" : posixPath.slice(0, lastSlashIndex);
+    const fileName =
+      lastSlashIndex === -1 ? posixPath : posixPath.slice(lastSlashIndex + 1);
+
+    const formData = new FormData();
+    formData.set("directory", directory);
+    formData.append("files", new File([new Uint8Array(fileBuffer)], fileName));
+
+    const response = await fetch(
+      `${apiBaseUrl}/api/admin/stores/${storeId}/theme-previews/${previewKey}/upload`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: formData,
+      },
+    );
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      return {
+        ok: false,
+        error: `Error subiendo ${relativePath}: ${response.status}${body ? ` — ${body}` : ""}`,
+      };
+    }
+
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Error subiendo ${relativePath}: ${error.message}`,
+    };
+  }
+};
+
+/**
+ * Delete a file from a preview.
+ *
+ * @param {string} apiBaseUrl
+ * @param {string} apiKey
+ * @param {number} storeId
+ * @param {string} previewKey
+ * @param {string} filePath
+ * @returns {Promise<{ ok: true } | { ok: false, error: string }>}
+ */
+export const deletePreviewFile = async (
+  apiBaseUrl,
+  apiKey,
+  storeId,
+  previewKey,
+  filePath,
+) => {
+  try {
+    const query = new URLSearchParams({ path: filePath }).toString();
+    const response = await apiFetch(
+      apiBaseUrl,
+      apiKey,
+      `/api/v2/stores/${storeId}/theme-previews/${previewKey}/file?${query}`,
+      {
+        method: "DELETE",
+      },
+    );
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      return {
+        ok: false,
+        error: `Error eliminando ${filePath}: ${response.status}${body ? ` — ${body}` : ""}`,
+      };
+    }
+
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Error eliminando ${filePath}: ${error.message}`,
+    };
+  }
+};

package/lib/config.mjs

@@ -0,0 +1,76 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+const CONFIG_DIR = ".cli";
+const CONFIG_FILE = "config.json";
+const CREDENTIALS_FILE = "credentials.json";
+
+/**
+ * @typedef {{ storeId: number, apiBaseUrl: string, previewKey?: string }} TienduConfig
+ * @typedef {{ apiKey: string }} TienduCredentials
+ */
+
+const getConfigDir = () => path.resolve(process.cwd(), CONFIG_DIR);
+const getConfigPath = () => path.join(getConfigDir(), CONFIG_FILE);
+const getCredentialsPath = () => path.join(getConfigDir(), CREDENTIALS_FILE);
+
+/** @returns {Promise<TienduConfig | null>} */
+export const readConfig = async () => {
+  try {
+    const raw = await readFile(getConfigPath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+
+/** @param {TienduConfig} config */
+export const writeConfig = async (config) => {
+  await mkdir(getConfigDir(), { recursive: true });
+  await writeFile(
+    getConfigPath(),
+    JSON.stringify(config, null, "\t") + "\n",
+    "utf-8",
+  );
+};
+
+/** @returns {Promise<TienduCredentials | null>} */
+export const readCredentials = async () => {
+  try {
+    const raw = await readFile(getCredentialsPath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+
+/** @param {TienduCredentials} credentials */
+export const writeCredentials = async (credentials) => {
+  await mkdir(getConfigDir(), { recursive: true });
+  await writeFile(
+    getCredentialsPath(),
+    JSON.stringify(credentials, null, "\t") + "\n",
+    "utf-8",
+  );
+};
+
+/**
+ * @returns {Promise<{ config: TienduConfig, credentials: TienduCredentials }>}
+ */
+export const loadConfigOrFail = async () => {
+  const config = await readConfig();
+  if (!config) {
+    console.error("No se encontró .cli/config.json");
+    console.error('Ejecutá "tiendu init" primero.');
+    process.exit(1);
+  }
+
+  const credentials = await readCredentials();
+  if (!credentials) {
+    console.error("No se encontró .cli/credentials.json");
+    console.error('Ejecutá "tiendu init" primero.');
+    process.exit(1);
+  }
+
+  return { config, credentials };
+};

package/lib/dev.mjs

@@ -0,0 +1,222 @@
+import { watch } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { loadConfigOrFail, writeConfig } from "./config.mjs";
+import { createPreview, listPreviews } from "./preview.mjs";
+import {
+  uploadPreviewFileMultipart,
+  deletePreviewFile,
+  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));
+};
+
+/**
+ * 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 = [];
+  for (const entry of entries) {
+    if (isDotfile(entry.name)) continue;
+    const abs = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await listAllFiles(rootDir, abs);
+      files.push(...nested);
+    } else if (entry.isFile()) {
+      files.push(abs);
+    }
+  }
+  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);
+  }
+  return Buffer.from(zipSync(entries, { level: 6 }));
+};
+
+export const dev = async () => {
+  const { config, credentials } = await loadConfigOrFail();
+  const { apiBaseUrl, storeId } = config;
+  const { apiKey } = credentials;
+  const rootDir = process.cwd();
+
+  let previewKey = config.previewKey;
+
+  // Ensure a preview exists
+  if (!previewKey) {
+    console.log("");
+    console.log("No hay preview activo. Creando uno...");
+
+    const result = await createPreview(apiBaseUrl, apiKey, storeId, "Dev");
+    if (!result.ok) {
+      console.error(`Error: ${result.error}`);
+      process.exit(1);
+    }
+
+    previewKey = result.data.previewKey;
+    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...");
+    const zipBuffer = await createZipFromDirectory(rootDir);
+    const uploadResult = await uploadPreviewZip(
+      apiBaseUrl,
+      apiKey,
+      storeId,
+      previewKey,
+      zipBuffer,
+    );
+    if (!uploadResult.ok) {
+      console.error(`Error subiendo archivos: ${uploadResult.error}`);
+      process.exit(1);
+    }
+    console.log("Archivos subidos.");
+  } else {
+    // Verify the preview still exists
+    const listResult = await listPreviews(apiBaseUrl, apiKey, storeId);
+    if (!listResult.ok) {
+      console.error(`Error: ${listResult.error}`);
+      process.exit(1);
+    }
+    const existing = listResult.data.find((p) => p.previewKey === previewKey);
+    if (!existing) {
+      console.error(
+        `El preview ${previewKey} ya no existe. Eliminá la config con: tiendu preview delete`,
+      );
+      process.exit(1);
+    }
+    console.log("");
+    console.log(`Preview activo: ${previewKey}`);
+    console.log(
+      `URL: ${buildPreviewUrl(apiBaseUrl, existing.previewHostname)}`,
+    );
+  }
+
+  console.log("");
+  console.log("Observando cambios... (Ctrl+C para salir)");
+  console.log("");
+
+  // Debounce map: relativePath -> timeout
+  /** @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}`);
+            const result = await deletePreviewFile(
+              apiBaseUrl,
+              apiKey,
+              storeId,
+              previewKey,
+              relativePath,
+            );
+            if (!result.ok) {
+              console.error(`    Error: ${result.error}`);
+            }
+          }
+          return;
+        }
+
+        // File was created or modified
+        const content = await readFile(absolutePath);
+        console.log(`  ↑ ${relativePath}`);
+
+        const result = await uploadPreviewFileMultipart(
+          apiBaseUrl,
+          apiKey,
+          storeId,
+          previewKey,
+          relativePath,
+          content,
+        );
+
+        if (!result.ok) {
+          console.error(`    Error: ${result.error}`);
+        }
+      } catch (error) {
+        console.error(`  Error procesando ${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.");
+    process.exit(0);
+  };
+
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+
+  // Keep process alive
+  await new Promise(() => {});
+};

package/lib/init.mjs

@@ -0,0 +1,92 @@
+import * as readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import {
+  readConfig,
+  readCredentials,
+  writeConfig,
+  writeCredentials,
+} from "./config.mjs";
+import { fetchStoreInfo } from "./api.mjs";
+
+export const init = async () => {
+  const existingConfig = await readConfig();
+  const existingCredentials = await readCredentials();
+
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+
+  try {
+    console.log("");
+    console.log("Tiendu CLI — Inicialización");
+    console.log("===========================");
+    console.log("");
+
+    // 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;
+
+    if (!apiKey) {
+      console.error("La API Key es requerida.");
+      process.exit(1);
+    }
+
+    // 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);
+    }
+
+    // Validate credentials against the server
+    console.log("");
+    console.log("Verificando credenciales...");
+
+    const storeInfo = await fetchStoreInfo(apiBaseUrl, apiKey, storeId);
+    if (!storeInfo.ok) {
+      console.error(`Error: ${storeInfo.error}`);
+      process.exit(1);
+    }
+
+    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("");
+  } finally {
+    rl.close();
+  }
+};
+
+/** @param {string} key */
+const maskApiKey = (key) => {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 4) + "..." + key.slice(-4);
+};
+
+/** @param {string} url */
+const normalizeBaseUrl = (url) => {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+};