easyorders 0.1.1 → 0.1.4

package/README.md

@@ -48,7 +48,7 @@ This will:
 
 ### Interactive mode
 
-Running `npx easy-orders` without arguments shows an interactive menu where you can choose to create a theme or start the dev server.
+Running `npx easyorders` without arguments shows an interactive menu where you can choose to create a theme or start the dev server.
 
 ## Environment Variables
 

package/dist/bin/cli.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import readline from "node:readline";
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { getCliVersion } from "../server/api.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const CLI_ROOT = path.resolve(__dirname, "..");
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+const YELLOW = "\x1b[33m";
+// ── Helpers ─────────────────────────────────────────────────
+function ask(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function copyDirSync(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirSync(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+// ── Commands ────────────────────────────────────────────────
+async function createTheme() {
+    let projectName = process.argv[3];
+    if (!projectName) {
+        projectName = await ask(`   ${BOLD}▸ Theme project name: ${RESET}`);
+    }
+    if (!projectName) {
+        console.error(`\n   ${RED}${BOLD}✖ Project name is required.${RESET}\n`);
+        process.exit(1);
+    }
+    const dest = path.resolve(process.cwd(), projectName);
+    if (fs.existsSync(dest)) {
+        console.error(`\n   ${RED}${BOLD}✖ Directory "${projectName}" already exists.${RESET}\n`);
+        process.exit(1);
+    }
+    console.log(`\n   ${DIM}Creating theme project${RESET} ${BOLD}${projectName}${RESET}…`);
+    // Create project directory
+    fs.mkdirSync(dest, { recursive: true });
+    // Copy template theme folder
+    const templateDir = path.join(CLI_ROOT, "template", "theme");
+    const themeDir = path.join(dest, "theme");
+    copyDirSync(templateDir, themeDir);
+    // Create a minimal package.json for the theme project
+    const pkg = {
+        name: projectName,
+        version: "0.1.0",
+        private: true,
+        scripts: {
+            dev: "easyorders start",
+        },
+    };
+    fs.writeFileSync(path.join(dest, "package.json"), JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+    // Create .gitignore
+    fs.writeFileSync(path.join(dest, ".gitignore"), [
+        "node_modules",
+        ".tunnel-url",
+        ".tunnel-pid",
+        ".auth-ready",
+        ".cli-tokens.json",
+        ".env",
+    ].join("\n") + "\n", "utf-8");
+    console.log(`   ${GREEN}${BOLD}✔${RESET} Theme project created at ${BOLD}${dest}${RESET}`);
+    console.log("");
+    console.log(`   ${DIM}Next steps:${RESET}`);
+    console.log(`     ${CYAN}cd ${projectName}${RESET}`);
+    console.log(`     ${CYAN}npx easyorders start${RESET}`);
+    console.log("");
+}
+async function startDev() {
+    // Resolve the theme directory from the current working directory
+    const cwd = process.cwd();
+    const themeDir = path.join(cwd, "theme");
+    if (!fs.existsSync(themeDir)) {
+        console.error(`\n   ${RED}${BOLD}✖ No "theme" folder found in the current directory.${RESET}`);
+        console.error(`   ${DIM}Run ${CYAN}npx easyorders create-theme <name>${DIM} first to create a project.${RESET}\n`);
+        process.exit(1);
+    }
+    // The server files are bundled inside the CLI package
+    const serverDir = path.join(CLI_ROOT, "server");
+    const indexScript = path.join(serverDir, "index.js");
+    const tunnelScript = path.join(serverDir, "tunnel.js");
+    const cmd = `node "${tunnelScript}" & node "${indexScript}"`;
+    const child = spawn(cmd, {
+        stdio: "inherit",
+        cwd,
+        env: { ...process.env, THEME_DIR: themeDir },
+        shell: true,
+    });
+    child.on("exit", (code) => {
+        process.exit(code ?? 0);
+    });
+}
+function showMenu() {
+    console.log("");
+    console.log(`   ${CYAN}${BOLD}Easy Orders CLI${RESET}`);
+    console.log("");
+    console.log(`   ${BOLD}Usage:${RESET}`);
+    console.log(`     ${CYAN}npx easyorders create-theme ${DIM}<name>${RESET}   Create a new theme project`);
+    console.log(`     ${CYAN}npx easyorders start${RESET}                  Start the dev server`);
+    console.log("");
+}
+async function interactiveMenu() {
+    console.log("");
+    console.log(`   ${CYAN}${BOLD}Easy Orders CLI${RESET}`);
+    console.log("");
+    console.log(`   ${BOLD}What would you like to do?${RESET}`);
+    console.log(`     ${BOLD}1)${RESET} Create a new theme`);
+    console.log(`     ${BOLD}2)${RESET} Start dev server`);
+    console.log("");
+    const choice = await ask(`   ${BOLD}▸ Choose (1/2): ${RESET}`);
+    switch (choice) {
+        case "1":
+            await createTheme();
+            break;
+        case "2":
+            await startDev();
+            break;
+        default:
+            console.error(`\n   ${RED}${BOLD}✖ Invalid choice.${RESET}\n`);
+            showMenu();
+            process.exit(1);
+    }
+}
+// ── Version check ───────────────────────────────────────────
+async function checkForUpdates() {
+    const pkgPath = path.resolve(__dirname, "..", "..", "package.json");
+    const localVersion = JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+    try {
+        const latestVersion = await getCliVersion();
+        if (latestVersion !== localVersion) {
+            console.log("");
+            console.log(`   ${YELLOW}${BOLD}⚠  Update available!${RESET} ${DIM}${localVersion}${RESET} → ${GREEN}${BOLD}${latestVersion}${RESET}`);
+            console.log(`   ${DIM}Run${RESET} ${CYAN}npm install -g easyorders@latest${RESET} ${DIM}to update.${RESET}`);
+            console.log("");
+            process.exit(1);
+        }
+    }
+    catch {
+        // If the version check fails (e.g. no network), skip silently
+    }
+}
+// ── Entry point ─────────────────────────────────────────────
+(async () => {
+    await checkForUpdates();
+    const command = process.argv[2];
+    switch (command) {
+        case "create-theme":
+            await createTheme();
+            break;
+        case "start":
+            await startDev();
+            break;
+        case "--help":
+        case "-h":
+            showMenu();
+            break;
+        default:
+            await interactiveMenu();
+            break;
+    }
+})();

package/dist/server/api.js

@@ -0,0 +1,22 @@
+import axios from "axios";
+const API_BASE_URL = process.env.API_BASE_URL || "https://api.easy-orders.net";
+function createClient() {
+    return axios.create({
+        baseURL: API_BASE_URL,
+        headers: { "Content-Type": "application/json" },
+        timeout: 10_000,
+    });
+}
+const client = createClient();
+export async function generateCliToken(storeName) {
+    const { data } = await client.post("/api/v1/themes/cli-token", { store_name: storeName });
+    return data;
+}
+export async function checkTokenStatus(tokenId) {
+    const { data } = await client.get("/api/v1/themes/cli-token/status", { params: { token_id: tokenId } });
+    return data;
+}
+export async function getCliVersion() {
+    const { data } = await client.get("/api/v1/themes/cli-version");
+    return data.version;
+}

package/dist/server/index.js

@@ -0,0 +1,255 @@
+import "dotenv/config";
+import cors from "cors";
+import express from "express";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { exec } from "node:child_process";
+import { generateCliToken, checkTokenStatus } from "./api.js";
+import { getToken, saveToken } from "./token-store.js";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+const UNDERLINE = "\x1b[4m";
+const YELLOW = "\x1b[33m";
+const FRONTEND_BASE_URL = process.env.FRONTEND_BASE_URL || "https://app.easy-orders.net";
+const STORE_DOMAIN = process.env.STORE_DOMAIN || "myeasyorders.com";
+const app = express();
+app.use(cors());
+const port = Number(process.env.PORT) || 4000;
+const URL_FILE = path.resolve(process.cwd(), ".tunnel-url");
+const THEME_DIR = process.env.THEME_DIR || path.resolve(process.cwd(), "theme");
+const SECTIONS_DIR = path.join(THEME_DIR, "sections");
+const AUTH_READY_FILE = path.resolve(process.cwd(), ".auth-ready");
+app.use(express.json());
+function getBaseUrl(req) {
+    try {
+        const tunnelUrl = fs.readFileSync(URL_FILE, "utf-8").trim();
+        if (tunnelUrl)
+            return tunnelUrl;
+    }
+    catch { }
+    return `${req.protocol}://${req.get("host")}`;
+}
+function toSnakeCase(filename) {
+    return filename.replace(/\.liquid$/, "").replace(/-/g, "_");
+}
+function readJsonFile(filepath) {
+    return JSON.parse(fs.readFileSync(filepath, "utf-8"));
+}
+function buildSections() {
+    const files = fs
+        .readdirSync(SECTIONS_DIR)
+        .filter((f) => f.endsWith(".liquid"));
+    return files.map((file) => ({
+        key: toSnakeCase(file),
+        template: fs.readFileSync(path.join(SECTIONS_DIR, file), "utf-8"),
+    }));
+}
+function extractSubdomain(input) {
+    const trimmed = input.trim();
+    try {
+        const url = new URL(trimmed);
+        const hostname = url.hostname;
+        const parts = hostname.split(".");
+        if (parts.length >= 2) {
+            return parts[0];
+        }
+    }
+    catch {
+        // Not a URL – continue
+    }
+    if (trimmed.includes(".")) {
+        return trimmed.split(".")[0];
+    }
+    return trimmed;
+}
+function promptStoreName() {
+    const args = process.argv.slice(2);
+    const idx = args.indexOf("--store_name");
+    if (idx !== -1 && idx + 1 < args.length) {
+        return Promise.resolve(args[idx + 1]);
+    }
+    if (process.env.STORE_NAME) {
+        return Promise.resolve(process.env.STORE_NAME);
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        console.log(`\n   ${CYAN}${BOLD}Enter your store subdomain${RESET} ${DIM}(e.g. "sand" from sand.${STORE_DOMAIN})${RESET}`);
+        rl.question(`   ${BOLD}▸ Subdomain: ${RESET}`, (answer) => {
+            rl.close();
+            const storeName = extractSubdomain(answer);
+            if (!storeName) {
+                console.error(`\n   ${RED}${BOLD}✖ Invalid input.${RESET} Please provide a valid subdomain.\n`);
+                process.exit(1);
+            }
+            console.log(`   ${GREEN}${BOLD}✔${RESET} ${DIM}Using store:${RESET} ${BOLD}${storeName}${RESET}`);
+            resolve(storeName);
+        });
+    });
+}
+function openBrowser(url) {
+    const cmd = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "start"
+            : "xdg-open";
+    exec(`${cmd} "${url}"`);
+}
+function waitForApproval(tokenId) {
+    return new Promise((resolve, reject) => {
+        const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+        let i = 0;
+        const spin = setInterval(() => {
+            process.stdout.write(`\r   ${YELLOW}${frames[i++ % frames.length]}${RESET} ${DIM}Waiting for approval…${RESET}`);
+        }, 100);
+        const poll = async () => {
+            try {
+                const { approved } = await checkTokenStatus(tokenId);
+                if (approved) {
+                    clearInterval(spin);
+                    process.stdout.write("\r\x1b[K");
+                    return resolve();
+                }
+                setTimeout(poll, 3000);
+            }
+            catch (err) {
+                clearInterval(spin);
+                process.stdout.write("\r\x1b[K");
+                reject(err);
+            }
+        };
+        poll();
+    });
+}
+async function authenticate(storeName) {
+    const existing = getToken(storeName);
+    if (existing) {
+        console.log(`\n   ${DIM}Found saved token for${RESET} ${BOLD}${storeName}${RESET}${DIM}, checking validity…${RESET}`);
+        try {
+            const { approved } = await checkTokenStatus(existing.token_id);
+            if (approved) {
+                console.log(`   ${GREEN}${BOLD}✔ Existing token is still valid!${RESET}\n`);
+                return existing.token;
+            }
+            console.log(`   ${YELLOW}${BOLD}⚠ Saved token is no longer valid. Generating a new one…${RESET}\n`);
+        }
+        catch {
+            console.log(`   ${YELLOW}${BOLD}⚠ Could not verify saved token. Generating a new one…${RESET}\n`);
+        }
+    }
+    console.log(`\n   ${DIM}Generating CLI token for store${RESET} ${BOLD}${storeName}${RESET}…`);
+    let tokenData;
+    try {
+        tokenData = await generateCliToken(storeName);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`\n   ${RED}${BOLD}✖ Failed to generate CLI token:${RESET} ${message}\n`);
+        process.exit(1);
+    }
+    const { store_id, token_id, token, expires_at } = tokenData;
+    const approveUrl = `${FRONTEND_BASE_URL}/#/approve-cli-token?store_id=${store_id}&token_id=${token_id}`;
+    console.log(`\n   ${YELLOW}${BOLD}⟶  Please approve the token in your browser:${RESET}`);
+    console.log(`   ${CYAN}${UNDERLINE}${approveUrl}${RESET}\n`);
+    openBrowser(approveUrl);
+    try {
+        await waitForApproval(token_id);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`\n   ${RED}${BOLD}✖ Token approval check failed:${RESET} ${message}\n`);
+        process.exit(1);
+    }
+    console.log(`   ${GREEN}${BOLD}✔ Token approved!${RESET}\n`);
+    saveToken({
+        store_name: storeName,
+        store_id,
+        token_id,
+        token,
+        expires_at,
+    });
+    return token;
+}
+// ── Express routes ──────────────────────────────────────────
+app.get("/health", (_req, res) => {
+    res.json({ ok: true });
+});
+app.get("/style.css", (_req, res) => {
+    const cssPath = path.join(THEME_DIR, "style.css");
+    try {
+        const css = fs.readFileSync(cssPath, "utf-8");
+        res.type("text/css").send(css);
+    }
+    catch {
+        res.status(404).type("text/css").send("/* style.css not found */");
+    }
+});
+app.get("/script.js", (_req, res) => {
+    const jsPath = path.join(THEME_DIR, "script.js");
+    try {
+        const js = fs.readFileSync(jsPath, "utf-8");
+        res.type("application/javascript").send(js);
+    }
+    catch {
+        res
+            .status(404)
+            .type("application/javascript")
+            .send("// script.js not found");
+    }
+});
+app.get("/", (_req, res) => {
+    res.json({ version: "1.0.0" });
+});
+app.get("/theme", (req, res) => {
+    const baseUrl = getBaseUrl(req);
+    res.json({
+        sections: buildSections(),
+        theme_data: readJsonFile(path.join(THEME_DIR, "theme-data.json")),
+        config: readJsonFile(path.join(THEME_DIR, "config.json")),
+        style: `${baseUrl}/style.css`,
+        script: `${baseUrl}/script.js`,
+    });
+});
+// ── Main ────────────────────────────────────────────────────
+function signalAuthReady(storeName, code) {
+    const data = JSON.stringify({ store_name: storeName, code });
+    fs.writeFileSync(AUTH_READY_FILE, data, "utf-8");
+}
+function cleanupAuthReady() {
+    try {
+        fs.unlinkSync(AUTH_READY_FILE);
+    }
+    catch { }
+}
+async function main() {
+    cleanupAuthReady();
+    const storeName = await promptStoreName();
+    const code = await authenticate(storeName);
+    signalAuthReady(storeName, code);
+    app.listen(port, () => {
+        console.log("");
+        console.log(`   ${CYAN}${BOLD}Theme Builder${RESET}`);
+        console.log(`   ${DIM}Server listening on${RESET} http://localhost:${port}`);
+        try {
+            const tunnelUrl = fs.readFileSync(URL_FILE, "utf-8").trim();
+            if (tunnelUrl) {
+                const themeUrl = `${tunnelUrl}/theme`;
+                const storeUrl = `https://${storeName}.${STORE_DOMAIN}?load_theme=${encodeURIComponent(themeUrl)}&code=${code}`;
+                console.log(`   ${GREEN}${BOLD}✔${RESET} ${DIM}Tunnel:${RESET}      ${CYAN}${UNDERLINE}${tunnelUrl}${RESET}`);
+                console.log(`   ${GREEN}${BOLD}✔${RESET} ${DIM}Open your store:${RESET}      ${CYAN}${UNDERLINE}${storeUrl}${RESET}`);
+            }
+        }
+        catch { }
+        console.log("");
+    });
+}
+process.once("SIGINT", () => cleanupAuthReady());
+process.once("SIGTERM", () => cleanupAuthReady());
+main();

package/dist/server/token-store.js

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+import path from "node:path";
+const TOKEN_FILE = path.resolve(process.cwd(), ".cli-tokens.json");
+function loadAll() {
+    try {
+        const raw = fs.readFileSync(TOKEN_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed;
+    }
+    catch { }
+    return [];
+}
+function saveAll(tokens) {
+    fs.writeFileSync(TOKEN_FILE, JSON.stringify(tokens, null, 2), "utf-8");
+}
+export function getToken(storeName) {
+    return loadAll().find((t) => t.store_name === storeName);
+}
+export function saveToken(entry) {
+    const tokens = loadAll().filter((t) => t.store_name !== entry.store_name);
+    tokens.push(entry);
+    saveAll(tokens);
+}

package/dist/server/tunnel.js

@@ -0,0 +1,124 @@
+import "dotenv/config";
+import { Tunnel } from "cloudflared";
+import fs from "node:fs";
+import path from "node:path";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+const UNDERLINE = "\x1b[4m";
+const STORE_DOMAIN = process.env.STORE_DOMAIN || "myeasyorders.com";
+const port = Number(process.env.PORT) || 4000;
+const URL_FILE = path.resolve(process.cwd(), ".tunnel-url");
+const PID_FILE = path.resolve(process.cwd(), ".tunnel-pid");
+const AUTH_READY_FILE = path.resolve(process.cwd(), ".auth-ready");
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function alreadyRunning() {
+    try {
+        const pid = parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10);
+        if (isAlive(pid)) {
+            const url = fs.readFileSync(URL_FILE, "utf-8").trim();
+            console.log(`   ${DIM}Tunnel already running (pid ${pid})${RESET}`);
+            console.log(`   ${DIM}Public URL:${RESET}  ${CYAN}${UNDERLINE}${url}${RESET}`);
+            return true;
+        }
+    }
+    catch { }
+    return false;
+}
+function spinner(text) {
+    const frames = ["   ◐", "   ◓", "   ◑", "   ◒"];
+    let i = 0;
+    return setInterval(() => {
+        process.stdout.write(`\r${CYAN}${frames[i++ % frames.length]}${RESET} ${DIM}${text}${RESET}`);
+    }, 120);
+}
+function cleanup() {
+    try {
+        fs.unlinkSync(URL_FILE);
+    }
+    catch { }
+    try {
+        fs.unlinkSync(PID_FILE);
+    }
+    catch { }
+}
+function waitForAuthReady() {
+    return new Promise((resolve) => {
+        const tryRead = () => {
+            if (fs.existsSync(AUTH_READY_FILE)) {
+                const raw = fs.readFileSync(AUTH_READY_FILE, "utf-8").trim();
+                try {
+                    const data = JSON.parse(raw);
+                    return resolve(data);
+                }
+                catch {
+                    return resolve({ store_name: "your-store", code: "" });
+                }
+            }
+        };
+        tryRead();
+        const check = setInterval(() => {
+            if (fs.existsSync(AUTH_READY_FILE)) {
+                clearInterval(check);
+                tryRead();
+            }
+        }, 500);
+    });
+}
+async function main() {
+    if (alreadyRunning())
+        return;
+    const authData = await waitForAuthReady();
+    fs.writeFileSync(PID_FILE, String(process.pid), "utf-8");
+    const spin = spinner("Starting Cloudflare tunnel...");
+    const tunnel = Tunnel.quick(`http://127.0.0.1:${port}`);
+    const tunnelUrl = await new Promise((resolve) => {
+        tunnel.once("url", (url) => resolve(url));
+    });
+    clearInterval(spin);
+    process.stdout.write("\r\x1b[K");
+    fs.writeFileSync(URL_FILE, tunnelUrl, "utf-8");
+    const themeUrl = `${tunnelUrl}/theme`;
+    const storeUrl = `https://${authData.store_name}.${STORE_DOMAIN}?load_theme=${encodeURIComponent(themeUrl)}&code=${authData.code}`;
+    console.log("");
+    console.log(`${GREEN}${BOLD}   ✔ Tunnel is live${RESET}`);
+    console.log("");
+    console.log(`   ${DIM}Public URL:${RESET}  ${CYAN}${UNDERLINE}${tunnelUrl}${RESET}`);
+    console.log(`   ${GREEN}${BOLD}✔${RESET} ${DIM}Open your store:${RESET}      ${CYAN}${UNDERLINE}${storeUrl}${RESET}`);
+    console.log(`   ${DIM}Local:${RESET}       http://127.0.0.1:${port}`);
+    console.log(`   ${DIM}─────────────────────────────────────────${RESET}`);
+    console.log("");
+    tunnel.once("connected", (conn) => {
+        console.log(`   ${GREEN}●${RESET} ${DIM}Connected via${RESET} ${BOLD}${conn.location}${RESET} ${DIM}(${conn.id.slice(0, 8)})${RESET}`);
+    });
+    tunnel.on("exit", (code, signal) => {
+        if (code !== 0) {
+            console.log(`\n   ${RED}✖ Tunnel exited${RESET} ${DIM}(code ${code}, signal ${signal})${RESET}\n`);
+        }
+        cleanup();
+    });
+    tunnel.on("error", (err) => {
+        console.log(`   ${YELLOW}⚠ ${err.message}${RESET}`);
+    });
+    process.once("SIGINT", () => {
+        cleanup();
+        tunnel.stop();
+    });
+    process.once("SIGTERM", () => {
+        cleanup();
+        tunnel.stop();
+    });
+}
+main();

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "easyorders",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "CLI tool for creating and developing Easy Orders themes",
+  "type": "module",
   "bin": {
-    "easyorders": "cli/bin/cli.ts"
+    "easyorders": "dist/bin/cli.js"
   },
   "files": [
-    "cli/"
+    "dist/"
   ],
   "keywords": [
     "easy-orders",
@@ -16,8 +17,9 @@
   ],
   "license": "MIT",
   "scripts": {
-    "dev": "tsx cli/bin/cli.ts start",
-    "create-theme": "tsx cli/bin/cli.ts create-theme"
+    "build": "tsc && cp -r cli/template dist/template",
+    "dev": "npx tsx cli/bin/cli.ts start",
+    "create-theme": "npx tsx cli/bin/cli.ts create-theme"
   },
   "dependencies": {
     "axios": "^1.9.0",