ecomiq 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ecomiq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,30 @@
-# Temporary Holding Version
+# ecomiq
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+CLI de Ecomiq para bajar, probar y publicar la tienda online como código.
+
+```bash
+npm install -g ecomiq
+ecomiq login
+ecomiq init mi-tienda
+cd mi-tienda && npm install
+ecomiq dev
+ecomiq publish
+```
+
+| Comando                 | Qué hace                                          |
+| ----------------------- | ------------------------------------------------- |
+| `ecomiq login [tienda]` | Inicia sesión y elige la tienda en el navegador.  |
+| `ecomiq logout`         | Cierra la sesión en este equipo y en Ecomiq.      |
+| `ecomiq init [carpeta]` | Baja el código de la tienda a una carpeta nueva.  |
+| `ecomiq dev`            | Levanta la tienda en local con sus datos reales.  |
+| `ecomiq pack [archivo]` | Construye el tema y lo comprime en un ZIP.        |
+| `ecomiq publish`        | Construye y sube una vista previa.                |
+| `ecomiq publish --live` | Construye, sube y publica en vivo.                |
+
+`publish` y `pack` no suben `node_modules`, `build`, `.env*`, `.dev.vars` ni
+los archivos ocultos de la raíz, salvo `.gitignore`. Los `.map` del build no se
+suben.
+
+Necesita Node.js 22.22 o superior.
+
+Guía completa: https://docs.ecomiq.pe/es/docs/guides/storefront/themes

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {}

package/dist/cli.js

@@ -0,0 +1,589 @@
+#!/usr/bin/env node
+import { platformFiles } from "./platform.js";
+import { spawn } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { createServer } from "node:http";
+import { homedir } from "node:os";
+import { crc32, deflateRawSync, gzipSync } from "node:zlib";
+// ../ecomiq-core/package.json
+var version$2 = "1.0.0";
+// ../react-router/package.json
+var version$1 = "1.0.0";
+// package.json
+var version = "0.1.0";
+// src/auth.ts
+const CALLBACK = "/ecomiq/cli/callback";
+const SCOPES = "openid profile email offline_access api_admin";
+const TIMEOUT = 3e5;
+const LEEWAY = 6e4;
+const LOCAL_ADMIN_URL = "http://localhost:8004";
+function adminUrl(local = false, environment = process.env) {
+	if (local) return LOCAL_ADMIN_URL;
+	return url(environment.ECOMIQ_ADMIN_URL?.trim() || "https://api-admin.ecomiq.pe", "ECOMIQ_ADMIN_URL");
+}
+function url(value, name) {
+	let parsed;
+	try {
+		parsed = new URL(value);
+	} catch {
+		throw new Error(`${name} debe ser una URL absoluta.`);
+	}
+	if (parsed.protocol !== "https:" && parsed.protocol !== "http:") throw new Error(`${name} debe usar http o https.`);
+	return parsed.href.replace(/\/+$/, "");
+}
+function credentialsPath(environment = process.env) {
+	const directory = environment.ECOMIQ_CONFIG_DIR?.trim() || join(environment.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config"), "ecomiq");
+	return join(directory, "credentials.json");
+}
+function readCredentials() {
+	const path = credentialsPath();
+	if (!existsSync(path)) return {
+		version: 1,
+		profiles: {}
+	};
+	const parsed = JSON.parse(readFileSync(path, "utf8"));
+	if (parsed === null || typeof parsed !== "object" || !("version" in parsed) || parsed.version !== 1 || !("profiles" in parsed)) throw new Error(`${path} no tiene un formato conocido.`);
+	return parsed;
+}
+function writeCredentials(credentials) {
+	const path = credentialsPath();
+	mkdirSync(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	writeFileSync(path, `${JSON.stringify(credentials, null, 2)}\n`, { mode: 384 });
+	chmodSync(path, 384);
+}
+function base64Url(bytes) {
+	return bytes.toString("base64url");
+}
+function claims(token) {
+	const payload = token.split(".")[1];
+	if (!payload) throw new Error("El token de acceso no es un JWT.");
+	return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+}
+function profile(tokens, apiUrl, tokenUrl, clientId, previous = null) {
+	if (typeof tokens.access_token !== "string" || tokens.access_token === "") throw new Error("No llegó un token de acceso.");
+	const claimSet = claims(tokens.access_token);
+	return {
+		apiUrl,
+		tokenUrl,
+		clientId,
+		accessToken: tokens.access_token,
+		refreshToken: typeof tokens.refresh_token === "string" ? tokens.refresh_token : previous?.refreshToken ?? null,
+		expiresAt: new Date(Date.now() + Math.max(0, Number(tokens.expires_in ?? 0)) * 1e3).toISOString(),
+		storeId: previous?.storeId ?? null,
+		storeSlug: previous?.storeSlug ?? null,
+		email: typeof claimSet.email === "string" ? claimSet.email : null
+	};
+}
+async function requestTokens(tokenUrl, form) {
+	const response = await fetch(tokenUrl, {
+		method: "POST",
+		headers: {
+			"content-type": "application/x-www-form-urlencoded",
+			accept: "application/json"
+		},
+		body: new URLSearchParams(form).toString()
+	});
+	const text = await response.text();
+	let body = {};
+	try {
+		body = text ? JSON.parse(text) : {};
+	} catch {
+		body = {};
+	}
+	if (!response.ok) throw new Error(`La autorización falló: ${String(body.error_description ?? body.error ?? `HTTP ${response.status}`)}`);
+	return body;
+}
+async function siteConfig(apiUrl) {
+	let response;
+	try {
+		response = await fetch(`${apiUrl}/v1/site/config`, { headers: { accept: "application/json" } });
+	} catch (error) {
+		throw new Error(`No se pudo contactar con Ecomiq (${apiUrl}): ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!response.ok) throw new Error(`Ecomiq respondió HTTP ${response.status} al preparar el inicio de sesión.`);
+	const config = await response.json();
+	if (config === null || typeof config !== "object" || !("issuer" in config) || typeof config.issuer !== "string" || !("tokenUrl" in config) || typeof config.tokenUrl !== "string" || !("revocationUrl" in config) || typeof config.revocationUrl !== "string" || !("clientId" in config) || typeof config.clientId !== "string" || !("storefrontApiUrl" in config) || typeof config.storefrontApiUrl !== "string") throw new Error("Ecomiq no devolvió la configuración esperada.");
+	return {
+		issuer: url(config.issuer, "issuer"),
+		tokenUrl: url(config.tokenUrl, "tokenUrl"),
+		revocationUrl: url(config.revocationUrl, "revocationUrl"),
+		clientId: config.clientId,
+		storefrontApiUrl: url(config.storefrontApiUrl, "storefrontApiUrl")
+	};
+}
+function browserCommand(address, platform = process.platform) {
+	if (platform === "darwin") return {
+		command: "open",
+		args: [address]
+	};
+	if (platform === "win32") return {
+		command: "rundll32",
+		args: ["url.dll,FileProtocolHandler", address]
+	};
+	return {
+		command: "xdg-open",
+		args: [address]
+	};
+}
+function openBrowser(address) {
+	const { command, args } = browserCommand(address);
+	const child = spawn(command, args, {
+		detached: true,
+		stdio: "ignore"
+	});
+	child.on("error", () => void 0);
+	child.unref();
+}
+function page(title, body) {
+	return `<!doctype html><meta charset="utf-8"><title>${title}</title><body style="font-family:system-ui;padding:3rem"><h1 style="font-size:1.25rem">${title}</h1><p>${body}</p></body>`;
+}
+function callback(server, state) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(/* @__PURE__ */ new Error("El inicio de sesión expiró.")), TIMEOUT);
+		server.on("request", (request, response) => {
+			const requested = new URL(request.url ?? "/", "http://127.0.0.1");
+			if (requested.pathname !== CALLBACK) {
+				response.writeHead(404).end();
+				return;
+			}
+			if (requested.searchParams.get("state") !== state) {
+				response.writeHead(400, { "content-type": "text/plain; charset=utf-8" }).end("Sesión no válida.");
+				return;
+			}
+			clearTimeout(timer);
+			const code = requested.searchParams.get("code");
+			response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+			if (!code) {
+				response.end(page("No se autorizó", "Cierra esta ventana e inténtalo de nuevo."));
+				reject(/* @__PURE__ */ new Error(`La autorización fue rechazada: ${requested.searchParams.get("error_description") ?? requested.searchParams.get("error") ?? "sin código"}`));
+				return;
+			}
+			response.end(page("Listo", "Vuelve a la terminal."));
+			resolve(code);
+		});
+	});
+}
+async function login(apiUrl, log) {
+	const { issuer, tokenUrl, clientId } = await siteConfig(apiUrl);
+	const verifier = base64Url(randomBytes(48));
+	const challenge = base64Url(createHash("sha256").update(verifier).digest());
+	const state = base64Url(randomBytes(24));
+	const server = createServer();
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", () => resolve());
+	});
+	try {
+		const redirectUri = `http://127.0.0.1:${server.address().port}${CALLBACK}`;
+		const authorize = new URL(`${issuer}/connect/authorize`);
+		for (const [name, value] of Object.entries({
+			client_id: clientId,
+			response_type: "code",
+			redirect_uri: redirectUri,
+			scope: SCOPES,
+			code_challenge: challenge,
+			code_challenge_method: "S256",
+			state
+		})) authorize.searchParams.set(name, value);
+		const code = callback(server, state);
+		log(`Si el navegador no se abre, entra a:\n  ${authorize.href}`);
+		openBrowser(authorize.href);
+		const created = profile(await requestTokens(tokenUrl, {
+			grant_type: "authorization_code",
+			client_id: clientId,
+			code: await code,
+			redirect_uri: redirectUri,
+			code_verifier: verifier
+		}), apiUrl, tokenUrl, clientId);
+		const credentials = readCredentials();
+		credentials.profiles[apiUrl] = created;
+		writeCredentials(credentials);
+		return created;
+	} finally {
+		await new Promise((resolve) => server.close(() => resolve()));
+	}
+}
+function chooseStore(apiUrl, storeId, storeSlug) {
+	const credentials = readCredentials();
+	const current = credentials.profiles[apiUrl];
+	if (!current) throw new Error("No has iniciado sesión. Ejecuta `ecomiq login`.");
+	credentials.profiles[apiUrl] = {
+		...current,
+		storeId,
+		storeSlug
+	};
+	writeCredentials(credentials);
+}
+async function revoke(apiUrl, current) {
+	if (!current.refreshToken) return;
+	const { revocationUrl } = await siteConfig(apiUrl);
+	const response = await fetch(revocationUrl, {
+		method: "POST",
+		headers: {
+			"content-type": "application/x-www-form-urlencoded",
+			accept: "application/json"
+		},
+		body: new URLSearchParams({
+			client_id: current.clientId,
+			token: current.refreshToken,
+			token_type_hint: "refresh_token"
+		}).toString()
+	});
+	if (!response.ok) throw new Error(`Ecomiq no cerró la sesión (HTTP ${response.status}). Inténtalo de nuevo.`);
+}
+async function logout(apiUrl) {
+	const credentials = readCredentials();
+	const current = credentials.profiles[apiUrl];
+	if (!current) return false;
+	await revoke(apiUrl, current);
+	delete credentials.profiles[apiUrl];
+	writeCredentials(credentials);
+	return true;
+}
+async function session(apiUrl, force = false) {
+	const credentials = readCredentials();
+	const current = credentials.profiles[apiUrl];
+	if (!current) throw new Error("No has iniciado sesión. Ejecuta `ecomiq login`.");
+	if (!force && Date.parse(current.expiresAt) - LEEWAY > Date.now()) return current;
+	if (!current.refreshToken || !current.tokenUrl) throw new Error("La sesión expiró. Ejecuta `ecomiq login`.");
+	const refreshed = profile(await requestTokens(current.tokenUrl, {
+		grant_type: "refresh_token",
+		client_id: current.clientId,
+		refresh_token: current.refreshToken
+	}), apiUrl, current.tokenUrl, current.clientId, current);
+	credentials.profiles[apiUrl] = refreshed;
+	writeCredentials(credentials);
+	return refreshed;
+}
+// src/api.ts
+async function problem(response) {
+	const text = await response.text();
+	try {
+		const body = JSON.parse(text);
+		if (body !== null && typeof body === "object" && "detail" in body && typeof body.detail === "string") return body.detail;
+	} catch {
+		return text || `HTTP ${response.status}`;
+	}
+	return text || `HTTP ${response.status}`;
+}
+async function call(apiUrl, path, init = () => ({})) {
+	const send = async (force) => {
+		const current = await session(apiUrl, force);
+		const request = init();
+		const headers = new Headers(request.headers);
+		headers.set("authorization", `Bearer ${current.accessToken}`);
+		headers.set("accept", "application/json");
+		if (current.storeId) headers.set("x-store-id", current.storeId);
+		return fetch(`${apiUrl}${path}`, {
+			...request,
+			headers
+		});
+	};
+	let response = await send(false);
+	if (response.status === 401) response = await send(true);
+	if (!response.ok) throw new Error(await problem(response));
+	return await response.json();
+}
+// src/tar.ts
+const BLOCK = 512;
+const SKIP = /* @__PURE__ */ new Set([
+	"node_modules",
+	"build",
+	"dist",
+	".react-router",
+	".wrangler",
+	".git",
+	".dev.vars",
+	".DS_Store"
+]);
+const ROOT_DOTFILES = /* @__PURE__ */ new Set([".gitignore"]);
+function octal(value, length) {
+	return value.toString(8).padStart(length - 1, "0") + "\0";
+}
+function split(path) {
+	if (Buffer.byteLength(path) <= 100) return {
+		name: path,
+		prefix: ""
+	};
+	const cut = path.lastIndexOf("/", path.length - 1);
+	for (let index = cut; index > 0; index = path.lastIndexOf("/", index - 1)) {
+		const prefix = path.slice(0, index);
+		const name = path.slice(index + 1);
+		if (Buffer.byteLength(prefix) <= 155 && Buffer.byteLength(name) <= 100) return {
+			name,
+			prefix
+		};
+	}
+	throw new Error(`Ruta demasiado larga para empaquetar: ${path}`);
+}
+function header(path, size) {
+	const block = Buffer.alloc(BLOCK);
+	const { name, prefix } = split(path);
+	block.write(name, 0, 100, "utf8");
+	block.write(octal(420, 8), 100, 8, "ascii");
+	block.write(octal(0, 8), 108, 8, "ascii");
+	block.write(octal(0, 8), 116, 8, "ascii");
+	block.write(octal(size, 12), 124, 12, "ascii");
+	block.write(octal(0, 12), 136, 12, "ascii");
+	block.fill(" ", 148, 156);
+	block.write("0", 156, 1, "ascii");
+	block.write("ustar\0", 257, 6, "ascii");
+	block.write("00", 263, 2, "ascii");
+	block.write(prefix, 345, 155, "utf8");
+	let checksum = 0;
+	for (const byte of block) checksum += byte;
+	block.write(octal(checksum, 7) + " ", 148, 8, "ascii");
+	return block;
+}
+function walk(root, skipped) {
+	const found = [];
+	const visit = (directory) => {
+		for (const entry of readdirSync(directory, { withFileTypes: true })) {
+			const absolute = join(directory, entry.name);
+			const path = relative(root, absolute).split(sep).join("/");
+			if (entry.name.startsWith(".env") || skipped(path, entry.name)) continue;
+			if (entry.isDirectory()) visit(absolute);
+			else if (entry.isFile()) found.push(path);
+		}
+	};
+	visit(root);
+	return found.sort();
+}
+function projectFiles(root) {
+	return walk(root, (path, name) => SKIP.has(name) || path === name && name.startsWith(".") && !ROOT_DOTFILES.has(name));
+}
+function buildFiles(root) {
+	return walk(root, (_path, name) => name === ".dev.vars" || name === ".DS_Store" || name.endsWith(".map"));
+}
+function pack(root, paths) {
+	const chunks = [];
+	for (const path of paths) {
+		const content = readFileSync(join(root, path));
+		if (!statSync(join(root, path)).isFile()) continue;
+		chunks.push(header(path, content.length), content, Buffer.alloc((BLOCK - content.length % BLOCK) % BLOCK));
+	}
+	chunks.push(Buffer.alloc(BLOCK * 2));
+	return gzipSync(Buffer.concat(chunks), { level: 9 });
+}
+// src/zip.ts
+function dosTime(date) {
+	const year = Math.max(1980, date.getFullYear());
+	return {
+		time: date.getHours() << 11 | date.getMinutes() << 5 | Math.floor(date.getSeconds() / 2),
+		day: year - 1980 << 9 | date.getMonth() + 1 << 5 | date.getDate()
+	};
+}
+function zip(root, paths, folder) {
+	const locals = [];
+	const centrals = [];
+	let offset = 0;
+	for (const path of paths) {
+		const content = readFileSync(join(root, path));
+		const deflated = deflateRawSync(content, { level: 9 });
+		const method = deflated.length < content.length ? 8 : 0;
+		const data = method === 8 ? deflated : content;
+		const name = Buffer.from(`${folder}/${path}`, "utf8");
+		const checksum = crc32(content);
+		const { time, day } = dosTime(statSync(join(root, path)).mtime);
+		const local = Buffer.alloc(30);
+		local.writeUInt32LE(67324752, 0);
+		local.writeUInt16LE(20, 4);
+		local.writeUInt16LE(2048, 6);
+		local.writeUInt16LE(method, 8);
+		local.writeUInt16LE(time, 10);
+		local.writeUInt16LE(day, 12);
+		local.writeUInt32LE(checksum, 14);
+		local.writeUInt32LE(data.length, 18);
+		local.writeUInt32LE(content.length, 22);
+		local.writeUInt16LE(name.length, 26);
+		const central = Buffer.alloc(46);
+		central.writeUInt32LE(33639248, 0);
+		central.writeUInt16LE(798, 4);
+		central.writeUInt16LE(20, 6);
+		central.writeUInt16LE(2048, 8);
+		central.writeUInt16LE(method, 10);
+		central.writeUInt16LE(time, 12);
+		central.writeUInt16LE(day, 14);
+		central.writeUInt32LE(checksum, 16);
+		central.writeUInt32LE(data.length, 20);
+		central.writeUInt32LE(content.length, 24);
+		central.writeUInt16LE(name.length, 28);
+		central.writeUInt32LE(33188 << 16 >>> 0, 38);
+		central.writeUInt32LE(offset, 42);
+		locals.push(local, name, data);
+		centrals.push(central, name);
+		offset += local.length + name.length + data.length;
+		if (offset > 4294967295) throw new Error("El tema es demasiado grande para comprimirlo.");
+	}
+	const directory = Buffer.concat(centrals);
+	const end = Buffer.alloc(22);
+	end.writeUInt32LE(101010256, 0);
+	end.writeUInt16LE(paths.length, 8);
+	end.writeUInt16LE(paths.length, 10);
+	end.writeUInt32LE(directory.length, 12);
+	end.writeUInt32LE(offset, 16);
+	return Buffer.concat([
+		...locals,
+		directory,
+		end
+	]);
+}
+// src/cli.ts
+const HELP = `Uso: ecomiq <comando>
+
+  login [tienda]   Inicia sesión y elige tu tienda en el navegador
+  logout           Cierra la sesión
+  init [carpeta]   Baja el código de tu tienda a una carpeta nueva
+  dev              Levanta la tienda en local con sus datos reales
+  pack [archivo]   Construye el tema y lo comprime en un ZIP para importarlo en Ecomiq
+  publish          Construye y sube una vista previa
+  publish --live   Construye, sube y publica en vivo
+
+  --local          Usa el backend local de desarrollo (${LOCAL_ADMIN_URL})
+`;
+const RELEASED = {
+	"@ecomiq/core": version$2,
+	"@ecomiq/react-router": version$1,
+	ecomiq: version
+};
+function binary(name) {
+	const path = join(process.cwd(), "node_modules", ".bin", process.platform === "win32" ? `${name}.cmd` : name);
+	if (!existsSync(path)) throw new Error("Instala las dependencias del proyecto (npm install).");
+	return path;
+}
+function run(command, args) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			stdio: "inherit",
+			shell: process.platform === "win32"
+		});
+		child.on("error", reject);
+		child.on("close", (code) => code === 0 ? resolve() : reject(/* @__PURE__ */ new Error(`${args[0] ?? command} terminó con código ${code}.`)));
+	});
+}
+function project() {
+	if (!["react-router.config.ts", "react-router.config.js"].some((name) => existsSync(name))) throw new Error("Ejecuta este comando dentro de tu proyecto (falta react-router.config.ts).");
+}
+function readVars(path) {
+	const vars = /* @__PURE__ */ new Map();
+	if (!existsSync(path)) return vars;
+	for (const line of readFileSync(path, "utf8").split("\n")) {
+		const match = /^\s*([A-Z0-9_]+)\s*=\s*(.*)\s*$/.exec(line);
+		if (match) vars.set(match[1], match[2]);
+	}
+	return vars;
+}
+function installableManifest(content) {
+	const manifest = JSON.parse(content);
+	for (const group of [manifest.dependencies ?? {}, manifest.devDependencies ?? {}]) for (const [name, range] of Object.entries(group)) if (range.startsWith("workspace:") && RELEASED[name] !== void 0) group[name] = `^${RELEASED[name]}`;
+	return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+async function init(apiUrl, folder) {
+	const site = await call(apiUrl, "/v1/site");
+	const target = resolve(folder ?? site.storeSlug);
+	if (existsSync(target) && readdirSync(target).length > 0) throw new Error(`La carpeta ${target} no está vacía.`);
+	const listed = await call(apiUrl, "/v1/site/files");
+	if (listed.files.length === 0) throw new Error(`La tienda ${site.storeSlug} todavía no tiene tema. Elige uno en Ecomiq.`);
+	const { files } = await call(apiUrl, "/v1/site/files?content=true");
+	const binaries = listed.files.filter((file) => file.encoding === "base64");
+	for (let index = 0; index < binaries.length; index += 8) files.push(...await Promise.all(binaries.slice(index, index + 8).map((file) => call(apiUrl, `/v1/site/file?path=${encodeURIComponent(file.path)}`))));
+	const platform = platformFiles(site.storeSlug, site.storeSlug, site.storefrontApiUrl).map((file) => ({
+		...file,
+		encoding: "utf8"
+	}));
+	for (const file of [...files, ...platform]) {
+		const destination = resolve(target, file.path);
+		if (!destination.startsWith(`${target}${sep}`)) throw new Error(`Ecomiq devolvió una ruta no permitida: ${file.path}`);
+		mkdirSync(dirname(destination), { recursive: true });
+		if (file.path === "package.json") writeFileSync(destination, installableManifest(file.content));
+		else writeFileSync(destination, file.encoding === "base64" ? Buffer.from(file.content, "base64") : file.content);
+	}
+	console.log(`✓ ${target} · ${files.length + platform.length} archivos`);
+	console.log(`  Sigue con: cd ${folder ?? site.storeSlug} && npm install && npx ecomiq dev`);
+}
+async function dev(apiUrl, args) {
+	project();
+	const site = await call(apiUrl, "/v1/site");
+	const vars = readVars(".dev.vars");
+	vars.set("ECOMIQ_STORE", site.storeSlug);
+	vars.set("ECOMIQ_API_URL", site.storefrontApiUrl);
+	if (!vars.get("SESSION_SECRET")) vars.set("SESSION_SECRET", randomBytes(32).toString("base64url"));
+	writeFileSync(".dev.vars", [...vars].map(([name, value]) => `${name}=${value}`).join("\n") + "\n", { mode: 384 });
+	console.log(`✓ Tienda ${site.storeSlug}`);
+	await run(binary("react-router"), ["dev", ...args]);
+}
+async function wait(apiUrl, id) {
+	const started = Date.now();
+	while (Date.now() - started < 9e5) {
+		const deployment = await call(apiUrl, `/v1/site/deployments/${id}`);
+		if (deployment.status === "ready" || deployment.status === "failed") return deployment;
+		await new Promise((resolve) => setTimeout(resolve, 3e3));
+	}
+	throw new Error("El despliegue tardó demasiado. Revisa su estado en Ecomiq.");
+}
+async function publish(apiUrl, live) {
+	project();
+	await run(binary("react-router"), ["build"]);
+	const form = new FormData();
+	form.set("build", new Blob([new Uint8Array(pack("build", buildFiles("build")))]), "build.tar.gz");
+	form.set("source", new Blob([new Uint8Array(pack(".", projectFiles(".")))]), "source.tar.gz");
+	console.log("Subiendo…");
+	const created = await call(apiUrl, "/v1/site/deployments", () => ({
+		method: "POST",
+		body: form
+	}));
+	console.log("Desplegando…");
+	const deployment = await wait(apiUrl, created.id);
+	if (deployment.status === "failed") throw new Error(deployment.error ?? "El despliegue falló.");
+	if (!live) {
+		console.log(`✓ Vista previa lista: ${deployment.previewUrl}`);
+		return;
+	}
+	const site = await call(apiUrl, "/v1/site");
+	await call(apiUrl, `/v1/site/deployments/${deployment.id}/live`, () => ({ method: "POST" }));
+	console.log(`✓ En vivo en ${site.storeSlug}`);
+}
+async function packTheme(output) {
+	project();
+	await run(binary("react-router"), ["build"]);
+	const folder = basename(process.cwd());
+	const target = resolve(output ?? join("..", `${folder}.zip`));
+	const paths = projectFiles(".").filter((path) => resolve(path) !== target);
+	writeFileSync(target, zip(".", paths, folder));
+	console.log(`✓ ${target} · ${paths.length} archivos`);
+	console.log("  Impórtalo en Tienda online → Personalizar tienda → Tema → Cambiar → Importar ZIP.");
+}
+async function main(argv) {
+	const [command, ...rest] = argv.filter((arg) => arg !== "--local");
+	const apiUrl = adminUrl(argv.includes("--local"));
+	if (command === "login") {
+		await login(apiUrl, (line) => console.log(line));
+		const store = await call(apiUrl, "/v1/stores/current/access");
+		const wanted = rest[0];
+		if (wanted !== void 0 && wanted !== store.storeSlug && wanted !== store.storeId) {
+			await logout(apiUrl);
+			throw new Error(`Autorizaste la tienda ${store.storeSlug}, no ${wanted}. Vuelve a iniciar sesión y elige ${wanted} en el navegador.`);
+		}
+		chooseStore(apiUrl, store.storeId, store.storeSlug);
+		console.log(`✓ Sesión iniciada · tienda ${store.storeSlug}`);
+	} else if (command === "logout") console.log(await logout(apiUrl) ? "✓ Sesión cerrada" : "No había una sesión abierta.");
+	else if (command === "init") await init(apiUrl, rest[0]);
+	else if (command === "dev") await dev(apiUrl, rest);
+	else if (command === "pack") await packTheme(rest[0]);
+	else if (command === "publish") await publish(apiUrl, rest.includes("--live"));
+	else if (command === "--version" || command === "-v") console.log(version);
+	else {
+		console.log(HELP);
+		if (command !== void 0 && command !== "help" && command !== "--help" && command !== "-h") process.exitCode = 1;
+	}
+}
+main(process.argv.slice(2)).catch((error) => {
+	console.error(`✗ ${error instanceof Error ? error.message : String(error)}`);
+	process.exitCode = 1;
+});
+export {};

package/dist/platform.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+export declare function platformFiles(name: string, store: string, apiUrl: string): {
+  path: string;
+  content: string;
+}[];

package/dist/platform.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+// src/platform.ts
+const VITE_CONFIG = String.raw`import { publicAssets, catalogLinks, paymentLogos, sectionLoaders, themeUi } from "@ecomiq/react-router/vite";
+import { fileURLToPath } from "node:url";
+import { cloudflare } from "@cloudflare/vite-plugin";
+import { reactRouter } from "@react-router/dev/vite";
+import tailwindcss from "@tailwindcss/vite";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [publicAssets(), catalogLinks(), sectionLoaders(), paymentLogos(), themeUi(), cloudflare({ viteEnvironment: { name: "ssr" } }), tailwindcss(), reactRouter()],
+  resolve: { alias: { "~": fileURLToPath(new URL("./app", import.meta.url)) } },
+  build: { rolldownOptions: { output: { codeSplitting: { groups: [{ name: "icons", test: /[\\/]node_modules[\\/](?:@phosphor-icons|@heroicons|@mdi|@remixicon|lucide-react|iconoir-react)[\\/]/ }] } } } },
+});
+`;
+const ROUTER_CONFIG = `import type { Config } from "@react-router/dev/config";
+
+export default {
+  ssr: true,
+} satisfies Config;
+`;
+const WORKER = `import { createRequestHandler } from "@ecomiq/react-router";
+
+export default createRequestHandler(() => import("virtual:react-router/server-build"), import.meta.env.MODE);
+`;
+function wrangler(name, store, apiUrl) {
+	return `{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": ${JSON.stringify(name)},
+  "main": "./workers/app.ts",
+  "compatibility_date": "2026-07-15",
+  "compatibility_flags": ["nodejs_compat"],
+  "vars": {
+    "ECOMIQ_STORE": ${JSON.stringify(store)},
+    "ECOMIQ_API_URL": ${JSON.stringify(apiUrl)}
+  }
+}
+`;
+}
+function platformFiles(name, store, apiUrl) {
+	return [
+		{
+			path: "vite.config.ts",
+			content: VITE_CONFIG
+		},
+		{
+			path: "react-router.config.ts",
+			content: ROUTER_CONFIG
+		},
+		{
+			path: "workers/app.ts",
+			content: WORKER
+		},
+		{
+			path: "wrangler.jsonc",
+			content: wrangler(name, store, apiUrl)
+		}
+	];
+}
+export { platformFiles };

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "ecomiq",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "CLI de Ecomiq para bajar, probar y publicar la tienda online",
+  "type": "module",
+  "license": "MIT",
+  "author": "Ecomiq",
+  "homepage": "https://docs.ecomiq.pe/es/docs/guides/storefront/themes",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ecomiq/ecomiq-storefront.git",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "ecomiq": "./dist/cli.js"
+  },
+  "exports": {
+    "./platform": {
+      "types": "./dist/platform.d.ts",
+      "import": "./dist/platform.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
 }