@feeef.dev/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,2730 @@
+// src/index.ts
+import { Command } from "commander";
+
+// src/client.ts
+import axios from "axios";
+import { FeeeF } from "feeef";
+
+// src/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var CONFIG_DIR = path.join(os.homedir(), ".config", "feeef");
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+function ensureConfigDir() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: DIR_MODE });
+  try {
+    fs.chmodSync(CONFIG_DIR, DIR_MODE);
+  } catch {
+  }
+}
+function writeConfigFile(data) {
+  ensureConfigDir();
+  const body = `${JSON.stringify(data, null, 2)}
+`;
+  fs.writeFileSync(CONFIG_PATH, body, { encoding: "utf8", mode: FILE_MODE });
+  try {
+    fs.chmodSync(CONFIG_PATH, FILE_MODE);
+  } catch {
+  }
+}
+function configPath() {
+  return CONFIG_PATH;
+}
+function loadConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_PATH)) return {};
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(patch) {
+  const next = { ...loadConfig(), ...patch };
+  for (const key of Object.keys(next)) {
+    const value = next[key];
+    if (value === void 0 || value === null || value === "") {
+      delete next[key];
+    }
+  }
+  writeConfigFile(next);
+  return next;
+}
+function clearAuth() {
+  const cfg = loadConfig();
+  delete cfg.token;
+  delete cfg.email;
+  writeConfigFile(cfg);
+}
+function defaultApiUrl(cfg = loadConfig()) {
+  return (process.env["FEEEF_API_BASE_URL"] || cfg.apiUrl || "https://api.feeef.org/v1").replace(/\/$/, "");
+}
+function defaultDevPort(cfg = loadConfig()) {
+  const fromEnv = Number(process.env["FEEEF_DEV_PORT"]);
+  if (Number.isFinite(fromEnv) && fromEnv > 0) return fromEnv;
+  if (typeof cfg.devPort === "number" && cfg.devPort > 0) return cfg.devPort;
+  return 3456;
+}
+
+// src/client.ts
+function createHttp(baseURL, token) {
+  return axios.create({
+    baseURL,
+    maxBodyLength: Infinity,
+    maxContentLength: Infinity,
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {}
+    }
+  });
+}
+function createClient(opts = {}) {
+  const requireAuth = opts.requireAuth !== false;
+  const cfg = loadConfig();
+  const baseURL = defaultApiUrl(cfg);
+  const token = cfg.token;
+  if (requireAuth && !token) {
+    throw new Error("Not signed in. Run: feeef signin");
+  }
+  const http2 = createHttp(baseURL, token);
+  const ff = new FeeeF({
+    apiKey: token || "",
+    baseURL,
+    client: http2,
+    cache: false
+  });
+  return { ff, http: http2, cfg, baseURL, token };
+}
+async function signinWithPassword(input) {
+  const baseURL = (input.apiUrl || defaultApiUrl()).replace(/\/$/, "");
+  const http2 = createHttp(baseURL, void 0);
+  const ff = new FeeeF({
+    apiKey: "",
+    baseURL,
+    client: http2,
+    cache: false
+  });
+  const auth = await ff.users.signin({
+    email: input.email,
+    password: input.password
+  });
+  const token = auth?.token?.token;
+  if (!token) {
+    throw new Error("Signin succeeded but no token was returned");
+  }
+  ff.setHeader("Authorization", `Bearer ${token}`);
+  saveConfig({ token, email: input.email, apiUrl: baseURL });
+  return auth;
+}
+
+// src/oauth.ts
+import crypto from "crypto";
+import http from "http";
+import { exec } from "child_process";
+import axios2 from "axios";
+import { FeeeF as FeeeF2, OAuthRepository } from "feeef";
+var DEFAULT_OAUTH_CLIENT_ID = "gan5yqm11fk4eh1ayheelkcs";
+var DEFAULT_OAUTH_REDIRECT_URI = "http://localhost.feeef.org:7777/oauth/callback";
+var DEFAULT_OAUTH_CALLBACK_PORT = 7777;
+var DEFAULT_CLI_OAUTH_SCOPES = [
+  "auth",
+  "store",
+  "store.settings",
+  "store_templates",
+  "store_templates.read"
+];
+function originOnly(raw) {
+  try {
+    const u = new URL(raw);
+    return `${u.protocol}//${u.host}`;
+  } catch {
+    return raw.replace(/\/$/, "");
+  }
+}
+function resolveAuthorizeBaseUrl(apiUrl) {
+  const fromEnv = process.env["FEEEF_ACCOUNTS_URL"]?.trim() || process.env["FEEEF_OAUTH_AUTHORIZE_BASE_URL"]?.trim();
+  if (fromEnv) return originOnly(fromEnv);
+  try {
+    const u = new URL(apiUrl);
+    if (u.hostname === "api.feeef.org") {
+      return "https://accounts.feeef.org";
+    }
+    if (u.hostname.startsWith("api.")) {
+      const host = u.hostname.replace(/^api\./, "accounts.");
+      const port = u.port ? `:${u.port}` : "";
+      return `${u.protocol}//${host}${port}`;
+    }
+    if (u.hostname === "127.0.0.1" || u.hostname === "localhost" || u.hostname === "localhost.feeef.org") {
+      const port = u.port ? `:${u.port}` : "";
+      return `http://accounts.localhost.feeef.org${port}`;
+    }
+    if (u.hostname.startsWith("accounts.")) {
+      return `${u.protocol}//${u.host}`;
+    }
+    return `${u.protocol}//${u.host}`;
+  } catch {
+    return apiUrl.replace(/\/$/, "");
+  }
+}
+function resolveOAuthSettings(apiUrlOverride) {
+  const clientId = process.env["FEEEF_OAUTH_CLIENT_ID"]?.trim() || DEFAULT_OAUTH_CLIENT_ID;
+  const clientSecret = process.env["FEEEF_OAUTH_CLIENT_SECRET"]?.trim() || void 0;
+  const redirectUri = process.env["FEEEF_OAUTH_REDIRECT_URI"]?.trim() || DEFAULT_OAUTH_REDIRECT_URI;
+  const callbackPort = Number(
+    process.env["FEEEF_OAUTH_CALLBACK_PORT"] || DEFAULT_OAUTH_CALLBACK_PORT
+  );
+  const apiUrl = (apiUrlOverride || defaultApiUrl()).replace(/\/$/, "");
+  const scopesEnv = process.env["FEEEF_OAUTH_SCOPES"]?.trim();
+  const scopes = scopesEnv ? scopesEnv.split(/[\s,]+/).filter(Boolean) : [...DEFAULT_CLI_OAUTH_SCOPES];
+  return {
+    clientId,
+    clientSecret,
+    redirectUri,
+    callbackPort: Number.isFinite(callbackPort) ? callbackPort : DEFAULT_OAUTH_CALLBACK_PORT,
+    apiUrl,
+    authorizeBaseUrl: resolveAuthorizeBaseUrl(apiUrl),
+    scopes
+  };
+}
+function createPkcePair() {
+  const verifier = crypto.randomBytes(32).toString("base64url");
+  const challenge = crypto.createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? `open "${url}"` : platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  exec(cmd, () => {
+  });
+}
+function htmlPage(title, body) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>${title}</title>
+  <style>
+    body { font-family: system-ui, sans-serif; max-width: 32rem; margin: 4rem auto; padding: 0 1rem; }
+    h1 { font-size: 1.25rem; }
+    p { color: #444; }
+  </style>
+</head>
+<body>
+  <h1>${title}</h1>
+  <p>${body}</p>
+  <p>You can close this tab and return to the terminal.</p>
+</body>
+</html>`;
+}
+function listenForOAuthCallback(opts) {
+  const timeoutMs = opts.timeoutMs ?? 5 * 60 * 1e3;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      fn();
+    };
+    const server = http.createServer((req, res) => {
+      try {
+        const url = new URL(req.url || "/", `http://127.0.0.1:${opts.port}`);
+        if (url.pathname !== "/oauth/callback") {
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end("Not found");
+          return;
+        }
+        const err = url.searchParams.get("error");
+        if (err) {
+          const desc = url.searchParams.get("error_description") || err;
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(htmlPage("Authorization failed", desc));
+          settle(() => {
+            server.close();
+            reject(new Error(desc));
+          });
+          return;
+        }
+        const returnedState = url.searchParams.get("state");
+        if (returnedState !== opts.expectedState) {
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(htmlPage("Invalid state", "CSRF check failed. Try again."));
+          settle(() => {
+            server.close();
+            reject(new Error("OAuth state mismatch"));
+          });
+          return;
+        }
+        const authCode = url.searchParams.get("code");
+        if (!authCode) {
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(htmlPage("Missing code", "No authorization code in callback."));
+          settle(() => {
+            server.close();
+            reject(new Error("Missing authorization code"));
+          });
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(htmlPage("Signed in", "Feeef CLI authorization complete."));
+        settle(() => {
+          server.close();
+          resolve(authCode);
+        });
+      } catch (e) {
+        settle(() => {
+          server.close();
+          reject(e);
+        });
+      }
+    });
+    server.on("error", (e) => {
+      settle(() => {
+        reject(
+          e instanceof Error && e.code === "EADDRINUSE" ? new Error(
+            `Port ${opts.port} is in use. Free it or set FEEEF_OAUTH_CALLBACK_PORT.`
+          ) : e
+        );
+      });
+    });
+    server.listen(opts.port, "127.0.0.1", () => {
+      opts.onListening?.();
+    });
+    setTimeout(() => {
+      settle(() => {
+        server.close();
+        reject(new Error("OAuth timed out waiting for browser callback"));
+      });
+    }, timeoutMs).unref();
+  });
+}
+async function signinWithOAuth(opts) {
+  const settings = resolveOAuthSettings(opts.apiUrl);
+  const state = crypto.randomUUID();
+  const { verifier, challenge } = createPkcePair();
+  const authorizeUrl = OAuthRepository.buildAuthorizeUrl({
+    baseUrl: settings.authorizeBaseUrl,
+    clientId: settings.clientId,
+    redirectUri: settings.redirectUri,
+    scope: settings.scopes,
+    state,
+    codeChallenge: challenge,
+    codeChallengeMethod: "S256"
+  });
+  opts.onAuthorizeUrl?.(authorizeUrl);
+  const code = await listenForOAuthCallback({
+    port: settings.callbackPort,
+    expectedState: state,
+    onListening: () => {
+      if (opts.openBrowser !== false) {
+        openBrowser(authorizeUrl);
+      }
+    }
+  });
+  const httpClient = axios2.create({
+    baseURL: settings.apiUrl,
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    }
+  });
+  const ff = new FeeeF2({
+    apiKey: "",
+    baseURL: settings.apiUrl,
+    client: httpClient,
+    cache: false
+  });
+  const tokenResponse = await ff.oauth.exchangeAuthorizationCode({
+    code,
+    redirectUri: settings.redirectUri,
+    clientId: settings.clientId,
+    ...settings.clientSecret ? { clientSecret: settings.clientSecret } : {},
+    codeVerifier: verifier
+  });
+  const accessToken = tokenResponse.access_token;
+  if (!accessToken) {
+    throw new Error("Token exchange returned no access_token");
+  }
+  saveConfig({
+    token: accessToken,
+    apiUrl: settings.apiUrl
+  });
+  ff.setHeader("Authorization", `Bearer ${accessToken}`);
+  try {
+    const me = await ff.users.me();
+    const payload = me;
+    const email = payload.user?.email || payload.email;
+    if (email) {
+      saveConfig({ email });
+      return { email };
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+
+// src/ui.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+function banner() {
+  console.log();
+  console.log(pc.cyan("  feeef") + pc.dim("  developer cli"));
+  console.log();
+}
+function intro2(title) {
+  p.intro(pc.bgCyan(pc.black(` ${title} `)));
+}
+function outro2(message) {
+  p.outro(pc.green(message));
+}
+function note2(message, title) {
+  p.note(message, title);
+}
+function cancel2(message = "Cancelled.") {
+  p.cancel(message);
+  process.exit(0);
+}
+async function text2(opts) {
+  const value = await p.text(opts);
+  if (p.isCancel(value)) cancel2();
+  return String(value);
+}
+async function password2(opts) {
+  const value = await p.password(opts);
+  if (p.isCancel(value)) cancel2();
+  return String(value);
+}
+async function confirm2(opts) {
+  const value = await p.confirm(opts);
+  if (p.isCancel(value)) cancel2();
+  return Boolean(value);
+}
+async function select2(opts) {
+  const value = await p.select(opts);
+  if (p.isCancel(value)) cancel2();
+  return value;
+}
+function fail(err) {
+  const anyErr = err;
+  let message;
+  if (anyErr?.response?.data != null) {
+    message = typeof anyErr.response.data === "string" ? anyErr.response.data : JSON.stringify(anyErr.response.data).slice(0, 1500);
+  } else if (err instanceof Error) {
+    message = err.message;
+  } else {
+    message = String(err);
+  }
+  p.log.error(pc.red(message));
+  process.exit(1);
+}
+function ok(message) {
+  p.log.success(message);
+}
+function info(message) {
+  p.log.info(message);
+}
+function warn(message) {
+  p.log.warn(message);
+}
+function spinner2() {
+  return p.spinner();
+}
+
+// src/commands/auth.ts
+async function runSignin(opts) {
+  intro2("feeef signin");
+  try {
+    const usePassword = Boolean(opts.passwordAuth) || Boolean(opts.email);
+    if (!usePassword) {
+      const s2 = spinner2();
+      s2.start("Waiting for browser authorization\u2026");
+      const result = await signinWithOAuth({
+        ...opts.apiUrl ? { apiUrl: opts.apiUrl } : {},
+        onAuthorizeUrl: (url) => {
+          s2.stop("Open this URL if the browser did not launch:");
+          note2(url, "Authorize");
+          s2.start("Waiting for callback on localhost.feeef.org:7777\u2026");
+        }
+      });
+      s2.stop(
+        result.email ? `Signed in as ${result.email}` : "Signed in (token saved)"
+      );
+      info(`Config: ${configPath()}`);
+      outro2("Ready. Try: feeef whoami");
+      return;
+    }
+    const email = opts.email || await text2({
+      message: "Email",
+      placeholder: "you@example.com",
+      validate: (v) => !v?.includes("@") ? "Enter a valid email" : void 0
+    });
+    const pass = opts.password || await password2({
+      message: "Password",
+      validate: (v) => !v || v.length < 8 ? "Min 8 characters" : void 0
+    });
+    const s = spinner2();
+    s.start("Signing in\u2026");
+    const auth = await signinWithPassword({
+      email,
+      password: pass,
+      ...opts.apiUrl ? { apiUrl: opts.apiUrl } : {}
+    });
+    s.stop(`Signed in as ${auth.user?.email || email}`);
+    info(`Config: ${configPath()}`);
+    outro2("Ready. Try: feeef whoami");
+  } catch (e) {
+    fail(e);
+  }
+}
+async function runWhoami() {
+  intro2("feeef whoami");
+  try {
+    const { ff, cfg } = createClient();
+    const me = await ff.users.me();
+    const payload = me;
+    const user = payload.user ?? payload;
+    ok(String(user.email || user.id || JSON.stringify(me)));
+    info(`API ${defaultApiUrl(cfg)}`);
+    outro2("Authenticated");
+  } catch (e) {
+    fail(e);
+  }
+}
+function runSignout() {
+  intro2("feeef signout");
+  clearAuth();
+  ok(`Cleared token (${configPath()})`);
+  outro2("Signed out");
+}
+function runConfigShow() {
+  intro2("feeef config");
+  const cfg = loadConfig();
+  console.log(
+    JSON.stringify(
+      {
+        path: configPath(),
+        email: cfg.email,
+        apiUrl: defaultApiUrl(cfg),
+        defaultStoreId: cfg.defaultStoreId,
+        lastPublishedTemplateId: cfg.lastPublishedTemplateId,
+        storefrontPath: cfg.storefrontPath,
+        devPort: cfg.devPort,
+        hasToken: Boolean(cfg.token)
+      },
+      null,
+      2
+    )
+  );
+  outro2("Done");
+}
+var CONFIG_KEYS = [
+  "apiUrl",
+  "defaultStoreId",
+  "storefrontPath",
+  "devPort",
+  "lastPublishedTemplateId"
+];
+function runConfigSet(key, value) {
+  intro2("feeef config set");
+  if (!CONFIG_KEYS.includes(key)) {
+    fail(`Unknown key "${key}". Allowed: ${CONFIG_KEYS.join(", ")}`);
+  }
+  const typedKey = key;
+  if (typedKey === "devPort") {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0) {
+      fail("devPort must be a positive number");
+    }
+    saveConfig({ devPort: n });
+  } else {
+    const patch = { [typedKey]: value };
+    saveConfig(patch);
+  }
+  ok(`Set ${typedKey}`);
+  outro2(configPath());
+}
+
+// src/commands/template/add.ts
+import path4 from "path";
+
+// src/project.ts
+import fs2 from "fs";
+import path2 from "path";
+var FEEF_RC = ".feeefrc";
+var TEMPLATE_META = "feeef.template.json";
+function findThemeRoot(startDir = process.cwd()) {
+  let dir = path2.resolve(startDir);
+  for (; ; ) {
+    if (fs2.existsSync(path2.join(dir, TEMPLATE_META))) return dir;
+    const parent = path2.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function loadProjectRc(themeRoot) {
+  const rcPath = path2.join(themeRoot, FEEF_RC);
+  try {
+    if (!fs2.existsSync(rcPath)) return {};
+    return JSON.parse(fs2.readFileSync(rcPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveProjectRc(themeRoot, patch) {
+  const rcPath = path2.join(themeRoot, FEEF_RC);
+  const next = { ...loadProjectRc(themeRoot), ...patch };
+  for (const key of Object.keys(next)) {
+    const value = next[key];
+    if (value === void 0 || value === null || value === "") {
+      delete next[key];
+    }
+  }
+  fs2.writeFileSync(rcPath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  return { rcPath, rc: next };
+}
+function loadTemplateMeta(themeRoot) {
+  const metaPath = path2.join(themeRoot, TEMPLATE_META);
+  if (!fs2.existsSync(metaPath)) return {};
+  try {
+    return JSON.parse(fs2.readFileSync(metaPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function resolveStoreIdFromProject(input) {
+  const rc = loadProjectRc(input.themeRoot);
+  const meta = loadTemplateMeta(input.themeRoot);
+  return input.storeFlag || rc.store || meta.store || meta.storeId || input.globalCfg.defaultStoreId || null;
+}
+function resolveThemeDir(dirArg) {
+  if (dirArg) {
+    const abs = path2.resolve(dirArg);
+    if (!fs2.existsSync(abs)) {
+      throw new Error(`Theme directory not found: ${abs}`);
+    }
+    return findThemeRoot(abs) || abs;
+  }
+  const fromCwd = findThemeRoot(process.cwd());
+  if (fromCwd) return fromCwd;
+  throw new Error(
+    "No theme found. Run inside a theme folder (feeef.template.json) or: feeef template init"
+  );
+}
+
+// src/theme-scaffold.ts
+import fs3 from "fs";
+import path3 from "path";
+var PAGE_ID_RE = /^[a-z][a-z0-9_]*$/;
+var COMPONENT_ID_RE = /^[a-z][a-z0-9_-]*$/;
+function assertPageId(id) {
+  const trimmed = id.trim();
+  if (!PAGE_ID_RE.test(trimmed)) {
+    throw new Error(
+      `Invalid page id "${id}" \u2014 use lowercase letters, digits, underscore (e.g. home, thank_you)`
+    );
+  }
+  return trimmed;
+}
+function assertComponentId(id) {
+  const trimmed = id.trim();
+  if (!COMPONENT_ID_RE.test(trimmed)) {
+    throw new Error(
+      `Invalid component id "${id}" \u2014 use lowercase letters, digits, hyphen/underscore (e.g. hero, product-grid)`
+    );
+  }
+  return trimmed;
+}
+function titleCaseFromId(id) {
+  return id.split(/[-_]/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function readMeta(themeRoot) {
+  const metaPath = path3.join(themeRoot, TEMPLATE_META);
+  if (!fs3.existsSync(metaPath)) {
+    throw new Error(`Missing ${TEMPLATE_META} in ${themeRoot}`);
+  }
+  return JSON.parse(fs3.readFileSync(metaPath, "utf8"));
+}
+function writeMeta(themeRoot, meta) {
+  const metaPath = path3.join(themeRoot, TEMPLATE_META);
+  fs3.writeFileSync(metaPath, `${JSON.stringify(meta, null, 2)}
+`, "utf8");
+}
+function pageUsesLegacySections(themeRoot, pageId) {
+  const flatDir = path3.join(themeRoot, "pages", pageId, "components");
+  if (fs3.existsSync(flatDir)) return false;
+  const sectionsDir = path3.join(themeRoot, "pages", pageId, "sections");
+  if (!fs3.existsSync(sectionsDir)) return false;
+  for (const section of fs3.readdirSync(sectionsDir, { withFileTypes: true })) {
+    if (!section.isDirectory() || section.name.startsWith(".")) continue;
+    const comps = path3.join(sectionsDir, section.name, "components");
+    if (!fs3.existsSync(comps)) continue;
+    const entries = fs3.readdirSync(comps).filter((n) => !n.startsWith("."));
+    if (entries.length > 0) return true;
+  }
+  return false;
+}
+function resolveComponentParentDir(themeRoot, pageId, section) {
+  if (section) {
+    const parentDir = path3.join(
+      themeRoot,
+      "pages",
+      pageId,
+      "sections",
+      section,
+      "components"
+    );
+    return { parentDir, kind: "legacy" };
+  }
+  if (pageUsesLegacySections(themeRoot, pageId)) {
+    return {
+      parentDir: path3.join(
+        themeRoot,
+        "pages",
+        pageId,
+        "sections",
+        "main",
+        "components"
+      ),
+      kind: "legacy"
+    };
+  }
+  return {
+    parentDir: path3.join(themeRoot, "pages", pageId, "components"),
+    kind: "flat"
+  };
+}
+function formatStarterComponent(opts) {
+  const order = typeof opts.order === "number" ? opts.order : 0;
+  const titleJson = JSON.stringify(opts.title);
+  return `const propsSchema = {
+  heading: { type: "string", name: "Heading" },
+} as const;
+
+export const meta = {
+  type: "custom",
+  title: ${titleJson},
+  order: ${order},
+  propsSchema,
+  props: {
+    heading: "",
+  },
+} as const satisfies FeeefComponentMeta<typeof propsSchema>;
+
+type Props = FeeefLivePropsOf<typeof propsSchema>;
+
+function App() {
+  const p = props as Props;
+  return (
+    <section style={{ padding: "2rem 1.5rem" }}>
+      <h2>{p.heading || ${titleJson}}</h2>
+    </section>
+  );
+}
+`;
+}
+function nextComponentOrder(parentDir) {
+  if (!fs3.existsSync(parentDir)) return 0;
+  let max = -1;
+  for (const name of fs3.readdirSync(parentDir)) {
+    if (name.startsWith(".")) continue;
+    const abs = path3.join(parentDir, name);
+    let sourcePath = null;
+    if (fs3.statSync(abs).isFile() && /\.(tsx|jsx)$/.test(name)) {
+      sourcePath = abs;
+    } else if (fs3.statSync(abs).isDirectory()) {
+      for (const entry of ["component.tsx", "component.jsx"]) {
+        const p2 = path3.join(abs, entry);
+        if (fs3.existsSync(p2)) {
+          sourcePath = p2;
+          break;
+        }
+      }
+    }
+    if (!sourcePath) continue;
+    const src = fs3.readFileSync(sourcePath, "utf8");
+    const m = /\border\s*:\s*(\d+)/.exec(src);
+    if (m) max = Math.max(max, Number(m[1]));
+  }
+  return max + 1;
+}
+function addPage(themeRoot, pageIdRaw) {
+  const pageId = assertPageId(pageIdRaw);
+  const pageDir = path3.join(themeRoot, "pages", pageId);
+  if (fs3.existsSync(pageDir)) {
+    throw new Error(`Page already exists: pages/${pageId}/`);
+  }
+  fs3.mkdirSync(path3.join(pageDir, "components"), { recursive: true });
+  fs3.writeFileSync(
+    path3.join(pageDir, "page.json"),
+    `${JSON.stringify({ props: {} }, null, 2)}
+`,
+    "utf8"
+  );
+  const meta = readMeta(themeRoot);
+  const pages = Array.isArray(meta.pages) ? [...meta.pages] : [];
+  if (!pages.includes(pageId)) pages.push(pageId);
+  meta.pages = pages;
+  writeMeta(themeRoot, meta);
+  return { pageDir, pageId };
+}
+function removePage(themeRoot, pageIdRaw) {
+  const pageId = assertPageId(pageIdRaw);
+  const pageDir = path3.join(themeRoot, "pages", pageId);
+  if (!fs3.existsSync(pageDir)) {
+    throw new Error(`Page not found: pages/${pageId}/`);
+  }
+  fs3.rmSync(pageDir, { recursive: true, force: true });
+  const meta = readMeta(themeRoot);
+  if (Array.isArray(meta.pages)) {
+    meta.pages = meta.pages.filter((id) => id !== pageId);
+    writeMeta(themeRoot, meta);
+  }
+  return { pageId, removedPath: pageDir };
+}
+function addComponent(themeRoot, pageIdRaw, componentIdRaw, opts = {}) {
+  const pageId = assertPageId(pageIdRaw);
+  const componentId = assertComponentId(componentIdRaw);
+  const pageDir = path3.join(themeRoot, "pages", pageId);
+  if (!fs3.existsSync(pageDir)) {
+    throw new Error(
+      `Page not found: pages/${pageId}/ \u2014 run: feeef template add page ${pageId}`
+    );
+  }
+  const { parentDir, kind } = resolveComponentParentDir(
+    themeRoot,
+    pageId,
+    opts.section
+  );
+  fs3.mkdirSync(parentDir, { recursive: true });
+  const filePath = path3.join(parentDir, `${componentId}.tsx`);
+  const folderPath = path3.join(parentDir, componentId);
+  if (fs3.existsSync(filePath) || fs3.existsSync(folderPath)) {
+    throw new Error(
+      `Component already exists under ${path3.relative(themeRoot, parentDir)}/${componentId}`
+    );
+  }
+  const order = nextComponentOrder(parentDir);
+  const title = opts.title?.trim() || titleCaseFromId(componentId);
+  fs3.writeFileSync(filePath, formatStarterComponent({ title, order }), "utf8");
+  return { filePath, pageId, componentId, kind };
+}
+function findComponentEntry(themeRoot, pageId, componentId, section) {
+  const candidates = [];
+  if (section) {
+    const base = path3.join(
+      themeRoot,
+      "pages",
+      pageId,
+      "sections",
+      section,
+      "components"
+    );
+    candidates.push(
+      path3.join(base, `${componentId}.tsx`),
+      path3.join(base, `${componentId}.jsx`),
+      path3.join(base, `${componentId}.json`),
+      path3.join(base, componentId)
+    );
+  } else {
+    const flat = path3.join(themeRoot, "pages", pageId, "components");
+    candidates.push(
+      path3.join(flat, `${componentId}.tsx`),
+      path3.join(flat, `${componentId}.jsx`),
+      path3.join(flat, `${componentId}.json`),
+      path3.join(flat, componentId)
+    );
+    const sectionsRoot = path3.join(themeRoot, "pages", pageId, "sections");
+    if (fs3.existsSync(sectionsRoot)) {
+      for (const sec of fs3.readdirSync(sectionsRoot, { withFileTypes: true })) {
+        if (!sec.isDirectory() || sec.name.startsWith(".")) continue;
+        const base = path3.join(sectionsRoot, sec.name, "components");
+        candidates.push(
+          path3.join(base, `${componentId}.tsx`),
+          path3.join(base, `${componentId}.jsx`),
+          path3.join(base, `${componentId}.json`),
+          path3.join(base, componentId)
+        );
+      }
+    }
+  }
+  for (const c of candidates) {
+    if (fs3.existsSync(c)) return c;
+  }
+  return null;
+}
+function removeComponent(themeRoot, pageIdRaw, componentIdRaw, opts = {}) {
+  const pageId = assertPageId(pageIdRaw);
+  const componentId = assertComponentId(componentIdRaw);
+  const entry = findComponentEntry(
+    themeRoot,
+    pageId,
+    componentId,
+    opts.section
+  );
+  if (!entry) {
+    throw new Error(
+      `Component not found: ${pageId}/${componentId}` + (opts.section ? ` (section ${opts.section})` : "")
+    );
+  }
+  fs3.rmSync(entry, { recursive: true, force: true });
+  return { pageId, componentId, removedPath: entry };
+}
+
+// src/commands/template/add.ts
+async function runTemplateAddPage(pageId, opts = {}) {
+  intro2("feeef template add page");
+  try {
+    if (!pageId?.trim()) {
+      fail("Usage: feeef template add page <pageId>");
+    }
+    const themeRoot = resolveThemeDir(opts.dir);
+    const { pageId: id } = addPage(themeRoot, pageId);
+    ok(`Created pages/${id}/ (flat components/)`);
+    outro2(`Next: feeef template add component ${id} <name>`);
+  } catch (err) {
+    fail(err instanceof Error ? err.message : String(err));
+  }
+}
+async function runTemplateAddComponent(pageId, componentId, opts = {}) {
+  intro2("feeef template add component");
+  try {
+    if (!pageId?.trim() || !componentId?.trim()) {
+      fail("Usage: feeef template add component <pageId> <componentId>");
+    }
+    const themeRoot = resolveThemeDir(opts.dir);
+    const result = addComponent(themeRoot, pageId, componentId, {
+      ...opts.title ? { title: opts.title } : {},
+      ...opts.section ? { section: opts.section } : {}
+    });
+    const rel = path4.relative(themeRoot, result.filePath);
+    ok(`Created ${rel}`);
+    if (result.kind === "legacy") {
+      outro2("Added under legacy sections/main (page already uses sections)");
+    } else {
+      outro2("Edit the file, then npm run build / npm run dev");
+    }
+  } catch (err) {
+    fail(err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/commands/template/build.ts
+import path6 from "path";
+
+// src/kit.ts
+import fs4 from "fs";
+import path5 from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+var __dirname = path5.dirname(fileURLToPath(import.meta.url));
+function cliRoot() {
+  const candidate = path5.resolve(__dirname, "..");
+  if (fs4.existsSync(path5.join(candidate, "package.json"))) return candidate;
+  return path5.resolve(__dirname, "../..");
+}
+function templateKitRoot() {
+  return path5.join(cliRoot(), "vendor", "template-kit");
+}
+function scaffoldsRoot() {
+  return path5.join(cliRoot(), "scaffolds");
+}
+async function loadBuild() {
+  const buildPath = path5.join(templateKitRoot(), "lib", "build.mjs");
+  if (!fs4.existsSync(buildPath)) {
+    throw new Error(`template-kit missing at ${buildPath}`);
+  }
+  return import(pathToFileURL(buildPath).href);
+}
+async function loadUnpack() {
+  const unpackPath = path5.join(templateKitRoot(), "lib", "unpack.mjs");
+  if (!fs4.existsSync(unpackPath)) {
+    throw new Error(`template-kit missing at ${unpackPath}`);
+  }
+  return import(pathToFileURL(unpackPath).href);
+}
+function kitBin() {
+  return path5.join(templateKitRoot(), "bin", "feeef-template.mjs");
+}
+
+// src/commands/template/build.ts
+async function runTemplateBuild(dirArg, opts = {}) {
+  const label = opts.checkOnly ? "feeef template check" : "feeef template build";
+  intro2(label);
+  try {
+    const srcDir = resolveThemeDir(dirArg);
+    const outPath = path6.join(srcDir, "dist", "data.json");
+    const s = spinner2();
+    s.start(opts.checkOnly ? "Checking theme\u2026" : "Building theme\u2026");
+    const { buildTemplate } = await loadBuild();
+    const result = buildTemplate({
+      srcDir,
+      outPath,
+      write: !opts.checkOnly
+    });
+    for (const w of result.warnings || []) {
+      warn(`[${w.path}] ${w.message}`);
+    }
+    s.stop(
+      opts.checkOnly ? `OK \u2014 ${result.pageCount ?? "?"} pages / ${result.componentCount ?? "?"} components` : `Built \u2192 ${result.outPath}`
+    );
+    if (!opts.checkOnly) {
+      if (result.localeCount) info(`${result.localeCount} locales`);
+      if (result.libraryCount) info(`${result.libraryCount} library entries`);
+    }
+    ok(opts.checkOnly ? "Check passed" : "Build complete");
+    outro2(opts.checkOnly ? "Ready to publish" : path6.relative(process.cwd(), outPath) || outPath);
+  } catch (e) {
+    fail(e);
+  }
+}
+
+// src/commands/template/dev.ts
+import { spawn } from "child_process";
+import fs6 from "fs";
+import path8 from "path";
+
+// src/storefront.ts
+import fs5 from "fs";
+import path7 from "path";
+function resolveStorefrontPath() {
+  const fromEnv = process.env["FEEEF_STOREFRONT_PATH"]?.trim();
+  if (fromEnv && fs5.existsSync(path7.join(fromEnv, "package.json"))) {
+    return path7.resolve(fromEnv);
+  }
+  const cfg = loadConfig();
+  if (cfg.storefrontPath && fs5.existsSync(path7.join(cfg.storefrontPath, "package.json"))) {
+    return path7.resolve(cfg.storefrontPath);
+  }
+  const sibling = path7.resolve(cliRoot(), "../storefront");
+  if (fs5.existsSync(path7.join(sibling, "package.json"))) {
+    return sibling;
+  }
+  return null;
+}
+function assertStorefrontPath() {
+  const root = resolveStorefrontPath();
+  if (!root) {
+    throw new Error(
+      [
+        "Lithium storefront not found.",
+        "Set it once (theme repos do not need storefront source inside them):",
+        "  feeef config set storefrontPath /path/to/storefront",
+        "or:",
+        "  export FEEEF_STOREFRONT_PATH=/path/to/storefront"
+      ].join("\n")
+    );
+  }
+  return root;
+}
+
+// src/commands/template/dev.ts
+function killChildren(children) {
+  for (const c of children) {
+    try {
+      c.kill("SIGTERM");
+    } catch {
+    }
+  }
+}
+function debounce(fn, ms) {
+  let timer;
+  const wrapped = ((...args) => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => fn(...args), ms);
+  });
+  wrapped.cancel = () => {
+    if (timer) clearTimeout(timer);
+  };
+  return wrapped;
+}
+async function resolveBoundStore(srcDir) {
+  const cfg = loadConfig();
+  if (!cfg.token) {
+    throw new Error(
+      "Not signed in. Run: feeef signin\nThen bind a store: feeef use <slug>"
+    );
+  }
+  const storeRef = resolveStoreIdFromProject({
+    themeRoot: srcDir,
+    globalCfg: cfg
+  });
+  if (!storeRef) {
+    throw new Error(
+      "No store linked. Run: feeef use <slug>\n(Remote preview pushes a draft to your store \u2014 live theme stays unchanged.)"
+    );
+  }
+  const { ff } = createClient({ requireAuth: true });
+  let store;
+  try {
+    store = await ff.stores.find({ id: storeRef });
+  } catch {
+    store = await ff.stores.find({ id: storeRef, by: "slug" });
+  }
+  return { storeId: store.id, slug: store.slug };
+}
+async function runRemoteDraftPreview(srcDir) {
+  const outPath = path8.join(srcDir, "dist", "data.json");
+  const { storeId, slug } = await resolveBoundStore(srcDir);
+  const { ff } = createClient({ requireAuth: true });
+  const s = spinner2();
+  s.start("Building theme\u2026");
+  const { buildTemplate } = await loadBuild();
+  buildTemplate({ srcDir, outPath, write: true });
+  s.stop("dist ready");
+  let lastPreviewUrl;
+  let pushInFlight = false;
+  let pushQueued = false;
+  const pushDraft = async () => {
+    if (pushInFlight) {
+      pushQueued = true;
+      return;
+    }
+    pushInFlight = true;
+    try {
+      if (!fs6.existsSync(outPath)) {
+        info("Waiting for dist/data.json\u2026");
+        return;
+      }
+      const data = JSON.parse(fs6.readFileSync(outPath, "utf8"));
+      const result = await ff.stores.putTemplatePreview(storeId, { data });
+      lastPreviewUrl = result.previewUrl;
+      ok(`Draft preview updated \u2192 ${pc.cyan(result.previewUrl)}`);
+    } catch (e) {
+      fail(e);
+    } finally {
+      pushInFlight = false;
+      if (pushQueued) {
+        pushQueued = false;
+        await pushDraft();
+      }
+    }
+  };
+  const debouncedPush = debounce(() => {
+    void pushDraft();
+  }, 400);
+  await pushDraft();
+  if (lastPreviewUrl) {
+    openBrowser(lastPreviewUrl);
+  }
+  note2(
+    [
+      `Theme   ${srcDir}`,
+      `Store   ${slug} (${storeId})`,
+      `Preview ${lastPreviewUrl ?? "(pending)"}`,
+      "",
+      "Live customers still see metadata.templateData.",
+      "Exit preview in the browser: banner \u2192 Exit, or /?preview=0",
+      "Stopping the CLI clears the draft."
+    ].join("\n"),
+    "Remote draft preview"
+  );
+  const watch = spawn(
+    process.execPath,
+    [kitBin(), "watch", srcDir, "-o", outPath],
+    { cwd: srcDir, env: process.env, stdio: "inherit" }
+  );
+  let watching = true;
+  const onDistChange = () => {
+    if (!watching) return;
+    debouncedPush();
+  };
+  try {
+    fs6.watch(path8.dirname(outPath), { persistent: true }, (_event, filename) => {
+      if (!filename || filename === "data.json" || String(filename).endsWith("data.json")) {
+        onDistChange();
+      }
+    });
+  } catch {
+    setInterval(() => onDistChange(), 2e3).unref();
+  }
+  const shutdown = async (code = 0) => {
+    watching = false;
+    debouncedPush.cancel();
+    killChildren([watch]);
+    try {
+      await ff.stores.clearTemplatePreview(storeId);
+      info("Cleared draft preview on server");
+    } catch {
+    }
+    process.exit(code);
+  };
+  process.on("SIGINT", () => {
+    void shutdown(0);
+  });
+  process.on("SIGTERM", () => {
+    void shutdown(0);
+  });
+  watch.on("exit", (code) => {
+    if (code && code !== 0) void shutdown(code);
+  });
+  ok(`Open ${pc.cyan(lastPreviewUrl ?? `https://${slug}.feeef.org`)}`);
+  outro2("Watching \u2014 Ctrl+C to stop (clears draft)");
+  await new Promise(() => {
+  });
+}
+async function runLocalStorefrontPreview(srcDir, opts) {
+  const outPath = path8.join(srcDir, "dist", "data.json");
+  const libraryPath = path8.join(srcDir, "dist", "schema.library.json");
+  const port = Number(opts.port) || defaultDevPort();
+  if (opts.storefront) {
+    process.env["FEEEF_STOREFRONT_PATH"] = path8.resolve(opts.storefront);
+  }
+  const storefrontRoot = assertStorefrontPath();
+  const cfg = loadConfig();
+  const storeRef = resolveStoreIdFromProject({
+    themeRoot: srcDir,
+    globalCfg: cfg
+  });
+  const rc = loadProjectRc(srcDir);
+  let slug = rc.slug;
+  if (!slug && storeRef) {
+    try {
+      const { ff } = createClient({ requireAuth: Boolean(cfg.token) });
+      if (cfg.token) {
+        try {
+          const store = await ff.stores.find({ id: storeRef });
+          slug = store.slug;
+        } catch {
+          try {
+            const store = await ff.stores.find({ id: storeRef, by: "slug" });
+            slug = store.slug;
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const s = spinner2();
+  s.start("Building theme\u2026");
+  const { buildTemplate } = await loadBuild();
+  buildTemplate({ srcDir, outPath, write: true });
+  s.stop("dist ready");
+  const previewHost = slug ? `http://${slug}.localhost.feeef.org:${port}` : `http://localhost:${port}`;
+  note2(
+    [
+      `Theme     ${srcDir}`,
+      `Storefront ${storefrontRoot}`,
+      `Preview   ${previewHost}`,
+      "Internal --local mode (not for public docs)."
+    ].join("\n"),
+    "Local Next preview"
+  );
+  const env = {
+    ...process.env,
+    FEEEF_TEMPLATE_DATA_PATH: outPath,
+    FEEEF_TEMPLATE_LIBRARY_PATH: libraryPath,
+    PORT: String(port)
+  };
+  if (slug) {
+    env["NEXT_PUBLIC_DEV_STORE_SLUG"] = slug;
+  }
+  const watch = spawn(
+    process.execPath,
+    [kitBin(), "watch", srcDir, "-o", outPath],
+    { cwd: srcDir, env, stdio: "inherit" }
+  );
+  const next = spawn(
+    "npx",
+    ["next", "dev", "--turbopack", "-H", "0.0.0.0", "-p", String(port)],
+    { cwd: storefrontRoot, env, stdio: "inherit", shell: true }
+  );
+  const children = [watch, next];
+  const shutdown = (code = 0) => {
+    killChildren(children);
+    process.exit(code);
+  };
+  process.on("SIGINT", () => shutdown(0));
+  process.on("SIGTERM", () => shutdown(0));
+  next.on("exit", (code) => shutdown(code ?? 0));
+  watch.on("exit", (code) => {
+    if (code && code !== 0) shutdown(code);
+  });
+  ok(`Open ${pc.cyan(previewHost)}`);
+  outro2("Watching \u2014 Ctrl+C to stop");
+  await new Promise(() => {
+  });
+}
+async function runTemplateDev(dirArg, opts) {
+  intro2("feeef template dev");
+  try {
+    const srcDir = resolveThemeDir(dirArg);
+    if (opts.local || opts.storefront) {
+      await runLocalStorefrontPreview(srcDir, opts);
+      return;
+    }
+    await runRemoteDraftPreview(srcDir);
+  } catch (e) {
+    fail(e);
+  }
+}
+
+// src/commands/template/init.ts
+import fs10 from "fs";
+import os2 from "os";
+import path12 from "path";
+import { TemplateComponentPolicy } from "feeef";
+
+// src/kits.ts
+import { execFileSync } from "child_process";
+import fs7 from "fs";
+import path9 from "path";
+var DEFAULT_BLANK_KIT_GIT = "https://github.com/feeef/theme-blank.git";
+function resolveBlankKitGitUrl(root = cliRoot()) {
+  const raw = process.env["FEEEF_THEME_BLANK_GIT"];
+  if (raw !== void 0) {
+    const trimmed = raw.trim();
+    if (trimmed === "" || trimmed === "0" || trimmed === "local") {
+      return void 0;
+    }
+    return trimmed;
+  }
+  const monorepoKit = path9.resolve(root, "..", "theme-kits", "blank");
+  if (fs7.existsSync(path9.join(monorepoKit, ".git"))) {
+    return monorepoKit;
+  }
+  return DEFAULT_BLANK_KIT_GIT;
+}
+function cloneKitFromGit(opts) {
+  const dest = path9.resolve(opts.dest);
+  if (fs7.existsSync(dest)) {
+    const entries = fs7.readdirSync(dest);
+    if (entries.length > 0) {
+      throw new Error(`Destination not empty: ${dest}`);
+    }
+    fs7.rmSync(dest, { recursive: true, force: true });
+  }
+  const depth = opts.depth ?? 1;
+  execFileSync(
+    "git",
+    ["clone", `--depth=${depth}`, opts.url, dest],
+    { stdio: ["ignore", "pipe", "pipe"] }
+  );
+  const gitDir = path9.join(dest, ".git");
+  if (fs7.existsSync(gitDir)) {
+    fs7.rmSync(gitDir, { recursive: true, force: true });
+  }
+  return { method: "git", source: opts.url };
+}
+function copyKitFromLocal(opts) {
+  if (!fs7.existsSync(opts.src)) {
+    throw new Error(`Local kit missing: ${opts.src}`);
+  }
+  opts.copyDir(opts.src, opts.dest);
+  return { method: "local", source: opts.src };
+}
+
+// src/theme-package.ts
+import fs8 from "fs";
+import path10 from "path";
+function packageNameFromFolder(name) {
+  return name.toLowerCase();
+}
+var DEFAULT_PACKAGE_JSON = {
+  name: "feeef-theme",
+  private: true,
+  version: "0.1.0",
+  description: "Feeef Lithium theme",
+  type: "module",
+  engines: { node: ">=18" },
+  scripts: {
+    build: "feeef template build",
+    check: "feeef template check",
+    dev: "feeef template dev",
+    publish: "feeef template publish",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {},
+  devDependencies: {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    typescript: "^5.4.5"
+  }
+};
+var DEFAULT_GITIGNORE = `node_modules/
+dist/
+.env
+.env.local
+.DS_Store
+`;
+var AGENT_PACK_ENTRIES = ["AGENTS.md", "docs", ".cursor"];
+var EDITOR_PACK_ENTRIES = [
+  "tsconfig.json",
+  "types",
+  ".vscode"
+];
+var EDITOR_DEV_DEPS = {
+  "@types/react": "^19.0.0",
+  "@types/react-dom": "^19.0.0",
+  typescript: "^5.4.5"
+};
+function copyDir(src, dest) {
+  fs8.mkdirSync(dest, { recursive: true });
+  for (const entry of fs8.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === "." || entry.name === "..") continue;
+    if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".env" || entry.name.startsWith(".env.")) {
+      continue;
+    }
+    const from = path10.join(src, entry.name);
+    const to = path10.join(dest, entry.name);
+    if (entry.isDirectory()) copyDir(from, to);
+    else fs8.copyFileSync(from, to);
+  }
+}
+function copyEntryIfMissing(from, to) {
+  if (!fs8.existsSync(from) || fs8.existsSync(to)) return false;
+  const st = fs8.statSync(from);
+  if (st.isDirectory()) copyDir(from, to);
+  else {
+    fs8.mkdirSync(path10.dirname(to), { recursive: true });
+    fs8.copyFileSync(from, to);
+  }
+  return true;
+}
+function ensureAgentPack(dest) {
+  const agentsPath = path10.join(dest, "AGENTS.md");
+  if (fs8.existsSync(agentsPath)) return false;
+  const blank = path10.join(scaffoldsRoot(), "blank");
+  let copied = false;
+  for (const name of AGENT_PACK_ENTRIES) {
+    if (copyEntryIfMissing(path10.join(blank, name), path10.join(dest, name))) {
+      copied = true;
+    }
+  }
+  return copied;
+}
+function ensureEditorSupport(dest) {
+  const blank = path10.join(scaffoldsRoot(), "blank");
+  let changed = false;
+  for (const name of EDITOR_PACK_ENTRIES) {
+    if (copyEntryIfMissing(path10.join(blank, name), path10.join(dest, name))) {
+      changed = true;
+    }
+  }
+  const scopeFrom = path10.join(blank, "types", "feeef-live-scope.d.ts");
+  const scopeTo = path10.join(dest, "types", "feeef-live-scope.d.ts");
+  if (copyEntryIfMissing(scopeFrom, scopeTo)) changed = true;
+  const themeSchemaFrom = path10.join(blank, "types", "feeef-template-schema.d.ts");
+  const themeSchemaTo = path10.join(dest, "types", "feeef-template-schema.d.ts");
+  if (copyEntryIfMissing(themeSchemaFrom, themeSchemaTo)) changed = true;
+  if (copyEntryIfMissing(path10.join(blank, "schema.ts"), path10.join(dest, "schema.ts"))) {
+    changed = true;
+  }
+  if (copyEntryIfMissing(path10.join(blank, "props.json"), path10.join(dest, "props.json"))) {
+    changed = true;
+  }
+  const pkgPath = path10.join(dest, "package.json");
+  if (fs8.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf8"));
+    const scripts = pkg.scripts && typeof pkg.scripts === "object" ? { ...pkg.scripts } : {};
+    if (!scripts.typecheck) {
+      scripts.typecheck = "tsc --noEmit";
+      pkg.scripts = scripts;
+      changed = true;
+    }
+    const devDeps = pkg.devDependencies && typeof pkg.devDependencies === "object" ? { ...pkg.devDependencies } : {};
+    for (const [name, version] of Object.entries(EDITOR_DEV_DEPS)) {
+      if (!devDeps[name]) {
+        devDeps[name] = version;
+        changed = true;
+      }
+    }
+    pkg.devDependencies = devDeps;
+    fs8.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  }
+  return changed;
+}
+function ensureNodePackage(dest, folderName) {
+  const pkgName = packageNameFromFolder(folderName);
+  const pkgPath = path10.join(dest, "package.json");
+  if (fs8.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf8"));
+    pkg.name = pkgName;
+    if (!pkg.scripts || typeof pkg.scripts !== "object") {
+      pkg.scripts = { ...DEFAULT_PACKAGE_JSON.scripts };
+    }
+    const scripts = pkg.scripts;
+    if (!scripts.typecheck) scripts.typecheck = "tsc --noEmit";
+    const devDeps = pkg.devDependencies && typeof pkg.devDependencies === "object" ? pkg.devDependencies : {};
+    for (const [name, version] of Object.entries(EDITOR_DEV_DEPS)) {
+      if (!devDeps[name]) devDeps[name] = version;
+    }
+    pkg.devDependencies = devDeps;
+    fs8.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  } else {
+    fs8.writeFileSync(
+      pkgPath,
+      `${JSON.stringify({ ...DEFAULT_PACKAGE_JSON, name: pkgName }, null, 2)}
+`,
+      "utf8"
+    );
+  }
+  const gitignorePath = path10.join(dest, ".gitignore");
+  if (!fs8.existsSync(gitignorePath)) {
+    fs8.writeFileSync(gitignorePath, DEFAULT_GITIGNORE, "utf8");
+  } else {
+    const existing = fs8.readFileSync(gitignorePath, "utf8");
+    const extras = [];
+    if (!/(^|\/)node_modules\/?$/m.test(existing) && !existing.includes("node_modules")) {
+      extras.push("node_modules/");
+    }
+    if (!/(^|\/)dist\/?$/m.test(existing) && !existing.includes("dist/")) {
+      extras.push("dist/");
+    }
+    if (extras.length > 0) {
+      const sep = existing.endsWith("\n") ? "" : "\n";
+      fs8.writeFileSync(
+        gitignorePath,
+        `${existing}${sep}${extras.join("\n")}
+`,
+        "utf8"
+      );
+    }
+  }
+}
+
+// src/theme.ts
+import fs9 from "fs";
+import path11 from "path";
+function collectPublishableComponents(srcDir) {
+  const out = [];
+  for (const kind of ["shared", "library"]) {
+    const root = path11.join(srcDir, kind, "components");
+    if (!fs9.existsSync(root)) continue;
+    const byId = /* @__PURE__ */ new Map();
+    for (const ent of fs9.readdirSync(root, { withFileTypes: true })) {
+      if (ent.name.startsWith(".")) continue;
+      if (ent.isDirectory()) {
+        byId.set(ent.name, path11.join(root, ent.name));
+      }
+    }
+    for (const ent of fs9.readdirSync(root, { withFileTypes: true })) {
+      if (ent.name.startsWith(".") || !ent.isFile()) continue;
+      const m = /^(.*)\.(tsx|jsx|json)$/.exec(ent.name);
+      if (!m) continue;
+      const id = m[1];
+      if (byId.has(id)) continue;
+      byId.set(id, path11.join(root, ent.name));
+    }
+    const entries = [...byId.entries()].map(([id, entryPath]) => ({ id, entryPath })).sort((a, b) => a.id.localeCompare(b.id));
+    for (const { id: name, entryPath } of entries) {
+      const isDir = fs9.statSync(entryPath).isDirectory();
+      const metaPath = isDir ? path11.join(entryPath, "component.json") : entryPath.endsWith(".json") ? entryPath : null;
+      const tsxPath = isDir ? path11.join(entryPath, "component.tsx") : entryPath.endsWith(".tsx") ? entryPath : null;
+      const jsxPath = isDir ? path11.join(entryPath, "component.jsx") : entryPath.endsWith(".jsx") ? entryPath : null;
+      const entry = tsxPath && fs9.existsSync(tsxPath) ? tsxPath : jsxPath && fs9.existsSync(jsxPath) ? jsxPath : null;
+      let meta = {};
+      if (metaPath && fs9.existsSync(metaPath)) {
+        meta = JSON.parse(fs9.readFileSync(metaPath, "utf8"));
+      }
+      let code = typeof meta["code"] === "string" ? meta["code"] : "";
+      if (entry) {
+        const source = fs9.readFileSync(entry, "utf8");
+        code = source;
+        const metaMatch = source.match(
+          /export\s+const\s+meta(?:\s+satisfies\s+[^=]+)?\s*=\s*(\{[\s\S]*?\})\s*(?:as\s+const)?\s*;?/
+        );
+        if (metaMatch?.[1]) {
+          try {
+            meta = { ...meta, ...new Function(`return (${metaMatch[1]})`)() };
+          } catch {
+          }
+        }
+      }
+      if (!code.trim() && !(metaPath && fs9.existsSync(metaPath))) continue;
+      if (!code.trim()) continue;
+      const sourceKey = typeof meta["libraryId"] === "string" && meta["libraryId"] || typeof meta["id"] === "string" && meta["id"] || name;
+      out.push({ sourceKey, kind, dir: entryPath, meta, code });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return out.filter((c) => {
+    if (seen.has(c.sourceKey)) return false;
+    seen.add(c.sourceKey);
+    return true;
+  });
+}
+function rewriteDataToReferences(data, codeToRefId) {
+  if (!data || typeof data !== "object") return data;
+  const walk = (node) => {
+    if (!node || typeof node !== "object") return node;
+    if (Array.isArray(node)) return node.map(walk);
+    const obj = node;
+    if ((obj["type"] === "custom" || !obj["type"]) && typeof obj["code"] === "string" && codeToRefId.has(obj["code"].trim())) {
+      const refId = codeToRefId.get(obj["code"].trim());
+      const {
+        code: _c,
+        propsSchema: _ps,
+        slotsSchema: _ss,
+        ...rest
+      } = obj;
+      return walk({ ...rest, type: "reference", refId });
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      out[k] = walk(v);
+    }
+    return out;
+  };
+  return walk(data);
+}
+function stripDataI18n(data) {
+  const clone = structuredClone(data);
+  delete clone["i18n"];
+  return clone;
+}
+function loadDistLocales(distDir, defaultLocale = "en") {
+  const localesDir = path11.join(distDir, "locales");
+  if (!fs9.existsSync(localesDir)) return [];
+  return fs9.readdirSync(localesDir).filter((f) => f.endsWith(".json")).map((f) => {
+    const locale = path11.basename(f, ".json");
+    const messages = JSON.parse(
+      fs9.readFileSync(path11.join(localesDir, f), "utf8")
+    );
+    return {
+      locale,
+      messages,
+      isDefault: locale === defaultLocale
+    };
+  });
+}
+var MAX_REF_DEPTH = 6;
+var MAX_REF_ROUNDS = 4;
+function collectTemplateRefIds(data) {
+  const out = /* @__PURE__ */ new Set();
+  const walkComp = (node, depth) => {
+    if (!node || typeof node !== "object" || depth > MAX_REF_DEPTH) return;
+    if (Array.isArray(node)) {
+      for (const item of node) walkComp(item, depth);
+      return;
+    }
+    const obj = node;
+    if (obj["type"] === "reference") {
+      const raw = obj["refId"] ?? obj["ref_id"];
+      if (typeof raw === "string" && raw.trim()) out.add(raw.trim());
+    }
+    if (Array.isArray(obj["children"])) {
+      for (const ch of obj["children"]) walkComp(ch, depth + 1);
+    }
+    if (obj["slots"] && typeof obj["slots"] === "object") {
+      for (const arr of Object.values(obj["slots"])) {
+        if (!Array.isArray(arr)) continue;
+        for (const ch of arr) walkComp(ch, depth + 1);
+      }
+    }
+  };
+  const pages = data?.pages;
+  if (!pages || typeof pages !== "object") return out;
+  for (const page of Object.values(pages)) {
+    const sections = page?.sections;
+    if (!sections) continue;
+    for (const section of Object.values(sections)) {
+      const comps = section?.components;
+      if (!Array.isArray(comps)) continue;
+      for (const c of comps) walkComp(c, 0);
+    }
+  }
+  return out;
+}
+function mergeDeep(base, override) {
+  if (!override || typeof override !== "object") return base ? { ...base } : {};
+  if (!base || typeof base !== "object") return { ...override };
+  const out = { ...base };
+  for (const key of Object.keys(override)) {
+    const ov = override[key];
+    const bv = base[key];
+    if (ov !== null && typeof ov === "object" && !Array.isArray(ov) && bv !== null && typeof bv === "object" && !Array.isArray(bv)) {
+      out[key] = mergeDeep(
+        bv,
+        ov
+      );
+    } else {
+      out[key] = ov;
+    }
+  }
+  return out;
+}
+function mergeSlots(base, override) {
+  const hasBase = !!(base && Object.keys(base).length > 0);
+  const hasOverride = !!(override && Object.keys(override).length > 0);
+  if (!hasBase && !hasOverride) return null;
+  const out = {};
+  if (hasBase) {
+    for (const [k, v] of Object.entries(base)) {
+      out[k] = Array.isArray(v) ? [...v] : [];
+    }
+  }
+  if (hasOverride) {
+    for (const [k, v] of Object.entries(override)) {
+      if (Array.isArray(v)) out[k] = v;
+    }
+  }
+  return out;
+}
+function materializeNode(comp, resolved, depth) {
+  if (!comp || depth > MAX_REF_DEPTH) return comp ?? null;
+  if (Array.isArray(comp["children"])) {
+    const next = [];
+    for (const child of comp["children"]) {
+      const rewritten = materializeNode(
+        child,
+        resolved,
+        depth + 1
+      );
+      if (rewritten) next.push(rewritten);
+    }
+    comp["children"] = next;
+  }
+  if (comp["slots"] && typeof comp["slots"] === "object") {
+    const slots = comp["slots"];
+    for (const [slotKey, arr] of Object.entries(slots)) {
+      if (!Array.isArray(arr)) continue;
+      const next = [];
+      for (const child of arr) {
+        const rewritten = materializeNode(
+          child,
+          resolved,
+          depth + 1
+        );
+        if (rewritten) next.push(rewritten);
+      }
+      slots[slotKey] = next;
+    }
+  }
+  if (comp["type"] !== "reference") return comp;
+  const refId = comp["refId"] ?? comp["ref_id"];
+  if (typeof refId !== "string" || !refId.trim()) return null;
+  const entry = resolved[refId.trim()];
+  if (!entry) return null;
+  const mergedProps = mergeDeep(
+    entry.propsDefault ?? {},
+    comp["props"] ?? {}
+  );
+  const mergedSlots = mergeSlots(
+    entry.slotsDefault,
+    comp["slots"]
+  );
+  const materialized = {
+    ...comp,
+    type: "custom",
+    code: entry.code,
+    propsSchema: entry.propsSchema ?? {},
+    slotsSchema: entry.slotsSchema ?? {},
+    props: mergedProps,
+    slots: mergedSlots
+  };
+  if (entry.slotsLayout != null && materialized["slotsLayout"] == null) {
+    materialized["slotsLayout"] = entry.slotsLayout;
+  }
+  delete materialized["refId"];
+  delete materialized["ref_id"];
+  delete materialized["refVersion"];
+  return materialized;
+}
+function rewriteReferencesInTemplateData(data, resolved) {
+  const pages = data["pages"];
+  if (!pages || typeof pages !== "object") return;
+  for (const page of Object.values(pages)) {
+    if (!page || typeof page !== "object") continue;
+    const sections = page["sections"];
+    if (!sections || typeof sections !== "object") continue;
+    for (const section of Object.values(sections)) {
+      if (!section || typeof section !== "object") continue;
+      const comps = section["components"];
+      if (!Array.isArray(comps)) continue;
+      const next = [];
+      for (const c of comps) {
+        const rewritten = materializeNode(
+          c,
+          resolved,
+          0
+        );
+        if (rewritten) next.push(rewritten);
+      }
+      section["components"] = next;
+    }
+  }
+}
+async function materializeTemplateReferences(opts) {
+  const catalog = {};
+  const allMissing = /* @__PURE__ */ new Set();
+  let resolvedCount = 0;
+  for (let round = 0; round < MAX_REF_ROUNDS; round++) {
+    const ids = [...collectTemplateRefIds(opts.data)].filter(
+      (id) => !(id in catalog)
+    );
+    if (ids.length === 0) break;
+    const res = await opts.resolve({
+      storeId: opts.sourceStoreId,
+      ids
+    });
+    const batch = res.resolved ?? {};
+    for (const [id, entry] of Object.entries(batch)) {
+      catalog[id] = entry;
+      resolvedCount += 1;
+    }
+    for (const id of res.missing ?? []) allMissing.add(id);
+    rewriteReferencesInTemplateData(opts.data, catalog);
+    if (Object.keys(batch).length === 0) break;
+  }
+  const leftover = [...collectTemplateRefIds(opts.data)];
+  for (const id of leftover) allMissing.add(id);
+  return {
+    resolved: resolvedCount,
+    missing: [...allMissing]
+  };
+}
+
+// src/commands/template/init.ts
+var PAGE_SIZE = 15;
+var LOAD_MORE = "__load_more__";
+var SEARCH = "__search__";
+var CLEAR_SEARCH = "__clear_search__";
+function copyDir2(src, dest) {
+  fs10.mkdirSync(dest, { recursive: true });
+  for (const entry of fs10.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === "." || entry.name === "..") continue;
+    if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".env" || entry.name.startsWith(".env.")) {
+      continue;
+    }
+    const from = path12.join(src, entry.name);
+    const to = path12.join(dest, entry.name);
+    if (entry.isDirectory()) copyDir2(from, to);
+    else fs10.copyFileSync(from, to);
+  }
+}
+function validateFolderName(v) {
+  if (!v || !/^[a-z0-9-_]+$/i.test(v)) {
+    return "Use letters, numbers, - or _";
+  }
+  return void 0;
+}
+function formatTemplateLabel(row) {
+  const title = row.title || row.id;
+  if (row.category) return `${title} \xB7 ${row.category}`;
+  return title;
+}
+function writeLocaleFiles(dest, messages) {
+  const localesDir = path12.join(dest, "locales");
+  fs10.mkdirSync(localesDir, { recursive: true });
+  let count = 0;
+  for (const [locale, tree] of Object.entries(messages)) {
+    fs10.writeFileSync(
+      path12.join(localesDir, `${locale}.json`),
+      `${JSON.stringify(tree, null, 2)}
+`,
+      "utf8"
+    );
+    count += 1;
+  }
+  return count;
+}
+function patchMeta(dest, patch) {
+  const metaPath = path12.join(dest, "feeef.template.json");
+  if (!fs10.existsSync(metaPath)) return;
+  const meta = JSON.parse(fs10.readFileSync(metaPath, "utf8"));
+  Object.assign(meta, patch);
+  fs10.writeFileSync(metaPath, `${JSON.stringify(meta, null, 2)}
+`, "utf8");
+}
+async function pickPublicTemplateInteractive(ff, initialQuery = "") {
+  let page = 1;
+  let query = initialQuery.trim();
+  const accumulated = [];
+  let total;
+  let lastBatchSize = 0;
+  const resetList = () => {
+    page = 1;
+    accumulated.length = 0;
+    total = void 0;
+    lastBatchSize = 0;
+  };
+  const fetchPage = async () => {
+    const s = spinner2();
+    const label = page === 1 ? query ? `Searching public templates for \u201C${query}\u201D\u2026` : "Loading public templates\u2026" : `Loading more (page ${page})\u2026`;
+    s.start(label);
+    const res = await ff.storeTemplates.list({
+      page,
+      limit: PAGE_SIZE,
+      policy: TemplateComponentPolicy.public,
+      ...query ? { q: query } : {}
+    });
+    s.stop(page === 1 ? "Templates loaded" : "More templates loaded");
+    if (typeof res.total === "number") total = res.total;
+    const batch = res.data || [];
+    lastBatchSize = batch.length;
+    accumulated.push(...batch);
+  };
+  for (; ; ) {
+    if (accumulated.length === 0) {
+      await fetchPage();
+    }
+    if (accumulated.length === 0) {
+      const again = await select2({
+        message: query ? `No public templates matched \u201C${query}\u201D` : "No public templates found",
+        options: [
+          { value: SEARCH, label: "Search again\u2026" },
+          ...query ? [{ value: CLEAR_SEARCH, label: "Clear search (show all)" }] : []
+        ]
+      });
+      if (again === CLEAR_SEARCH) {
+        query = "";
+        resetList();
+        continue;
+      }
+      query = (await text2({
+        message: "Search templates",
+        placeholder: "dawn, fashion, \u2026"
+      })).trim();
+      resetList();
+      continue;
+    }
+    const hasMore = lastBatchSize >= PAGE_SIZE && (total == null || accumulated.length < total);
+    const options = [
+      ...accumulated.map((row) => ({
+        value: row.id,
+        label: formatTemplateLabel(row),
+        hint: row.id
+      })),
+      {
+        value: SEARCH,
+        label: `${pc.dim("\u2315")} Search\u2026`,
+        hint: query ? `current: ${query}` : "filter by title"
+      }
+    ];
+    if (query) {
+      options.push({
+        value: CLEAR_SEARCH,
+        label: `${pc.dim("\xD7")} Clear search`,
+        hint: query
+      });
+    }
+    if (hasMore) {
+      const hint = total != null ? `${accumulated.length} of ${total}` : `loaded ${accumulated.length}`;
+      options.push({
+        value: LOAD_MORE,
+        label: `${pc.dim("\u2192")} Load more\u2026`,
+        hint
+      });
+    }
+    const chosen = await select2({
+      message: query ? `Pick a public template (search: ${query})` : "Pick a public template",
+      options
+    });
+    if (chosen === SEARCH) {
+      query = (await text2({
+        message: "Search templates",
+        placeholder: "dawn, fashion, \u2026",
+        initialValue: query
+      })).trim();
+      resetList();
+      continue;
+    }
+    if (chosen === CLEAR_SEARCH) {
+      query = "";
+      resetList();
+      continue;
+    }
+    if (chosen === LOAD_MORE) {
+      page += 1;
+      await fetchPage();
+      if (lastBatchSize === 0) {
+        info("No more templates");
+        total = accumulated.length;
+      }
+      continue;
+    }
+    const picked = accumulated.find((row) => row.id === chosen);
+    if (!picked) fail("Selected template not found");
+    return picked;
+  }
+}
+async function initFromBlank(dest, name, opts = {}) {
+  const blank = path12.join(scaffoldsRoot(), "blank");
+  const gitUrl = opts.gitUrl || resolveBlankKitGitUrl();
+  let result;
+  if (gitUrl) {
+    const s = spinner2();
+    s.start(`Cloning kit from ${gitUrl}\u2026`);
+    try {
+      result = cloneKitFromGit({ url: gitUrl, dest });
+      s.stop("Kit cloned");
+    } catch (e) {
+      s.stop("Git clone failed \u2014 falling back to local blank scaffold");
+      warn(
+        e instanceof Error ? e.message : String(e)
+      );
+      if (fs10.existsSync(dest)) {
+        fs10.rmSync(dest, { recursive: true, force: true });
+      }
+      if (!fs10.existsSync(blank)) {
+        fail(`Scaffold missing at ${blank}`);
+      }
+      result = copyKitFromLocal({ src: blank, dest, copyDir: copyDir2 });
+    }
+  } else {
+    if (!fs10.existsSync(blank)) {
+      fail(`Scaffold missing at ${blank}`);
+    }
+    result = copyKitFromLocal({ src: blank, dest, copyDir: copyDir2 });
+  }
+  patchMeta(dest, { name });
+  ensureNodePackage(dest, name);
+  ensureAgentPack(dest);
+  ensureEditorSupport(dest);
+  return result;
+}
+async function initFromPublicTemplate(dest, name, templateId, ff) {
+  const download = spinner2();
+  download.start("Downloading template\u2026");
+  const full = await ff.storeTemplates.find({ id: templateId });
+  download.stop("Template downloaded");
+  const data = full.data;
+  if (!data || typeof data !== "object" || !("pages" in data)) {
+    fail("Template has no usable data.pages \u2014 cannot unpack");
+  }
+  const dataForUnpack = structuredClone(data);
+  if (full.storeId) {
+    const matSpin = spinner2();
+    matSpin.start("Inlining library references\u2026");
+    try {
+      const mat = await materializeTemplateReferences({
+        data: dataForUnpack,
+        sourceStoreId: full.storeId,
+        resolve: (args) => ff.actions.resolveComponents(args)
+      });
+      if (mat.missing.length > 0) {
+        matSpin.stop(
+          `Inlined ${mat.resolved} library component(s); ${mat.missing.length} missing`
+        );
+        warn(
+          `Unresolved refId(s): ${mat.missing.slice(0, 8).join(", ")}${mat.missing.length > 8 ? "\u2026" : ""}`
+        );
+      } else {
+        matSpin.stop(
+          mat.resolved > 0 ? `Inlined ${mat.resolved} library component(s)` : "No library references to inline"
+        );
+      }
+    } catch (e) {
+      matSpin.stop("Could not inline library references");
+      warn(e instanceof Error ? e.message : String(e));
+    }
+  } else {
+    warn("Template has no storeId \u2014 skipping library reference inline");
+  }
+  const tmpDir = fs10.mkdtempSync(path12.join(os2.tmpdir(), "feeef-init-"));
+  const dataPath = path12.join(tmpDir, "data.json");
+  try {
+    fs10.writeFileSync(
+      dataPath,
+      `${JSON.stringify(dataForUnpack, null, 2)}
+`,
+      "utf8"
+    );
+    const { unpackTemplate } = await loadUnpack();
+    const unpackSpin = spinner2();
+    unpackSpin.start("Unpacking theme files\u2026");
+    const stats = unpackTemplate({
+      inputPath: dataPath,
+      outDir: dest,
+      force: true
+    });
+    unpackSpin.stop(
+      `Unpacked ${stats.pages} pages / ${stats.components} components (${stats.files} files)`
+    );
+  } finally {
+    fs10.rmSync(tmpDir, { recursive: true, force: true });
+  }
+  let localeCount = 0;
+  let defaultLocale;
+  try {
+    const localeSpin = spinner2();
+    localeSpin.start("Fetching locales\u2026");
+    const locales = await ff.storeTemplates.listLocales(templateId);
+    localeSpin.stop("Locales loaded");
+    defaultLocale = locales.defaultLocale;
+    if (locales.messages && Object.keys(locales.messages).length > 0) {
+      localeCount = writeLocaleFiles(dest, locales.messages);
+    }
+  } catch {
+    const embedded = data.i18n;
+    if (embedded?.messages) {
+      localeCount = writeLocaleFiles(dest, embedded.messages);
+      defaultLocale = embedded.defaultLocale;
+    }
+  }
+  patchMeta(dest, {
+    name,
+    ...defaultLocale ? { defaultLocale } : {},
+    sourceTemplateId: templateId,
+    sourceTitle: full.title
+  });
+  ensureNodePackage(dest, name);
+  ensureAgentPack(dest);
+  ensureEditorSupport(dest);
+  saveProjectRc(dest, { templateId });
+  const readmePath = path12.join(dest, "README.md");
+  if (!fs10.existsSync(readmePath)) {
+    fs10.writeFileSync(
+      readmePath,
+      [
+        `# ${name}`,
+        "",
+        `Cloned from public template **${full.title}** (\`${templateId}\`).`,
+        "",
+        "This folder is a Node.js package \u2014 scripts wrap the global `feeef` CLI.",
+        "",
+        "```bash",
+        "feeef signin",
+        "feeef use",
+        "npm run build",
+        "npm run dev",
+        "npm run publish -- --apply",
+        "```",
+        ""
+      ].join("\n"),
+      "utf8"
+    );
+  }
+  return { title: full.title, localeCount };
+}
+async function runTemplateInit(nameArg, opts = {}) {
+  intro2("feeef template init");
+  try {
+    let source = opts.blank ? "blank" : opts.from ? "public" : opts.git ? "git" : await select2({
+      message: "Start from",
+      options: [
+        {
+          value: "blank",
+          label: "Blank theme",
+          hint: resolveBlankKitGitUrl() ? "git clone official / monorepo kit" : "local scaffold"
+        },
+        {
+          value: "git",
+          label: "Git kit URL",
+          hint: "clone --depth 1 (Adonis/Laravel style)"
+        },
+        {
+          value: "public",
+          label: "Public marketplace template",
+          hint: "search + unpack"
+        }
+      ]
+    });
+    const name = nameArg || await text2({
+      message: "Theme folder name",
+      placeholder: "my-theme",
+      validate: validateFolderName
+    });
+    const dest = path12.resolve(process.cwd(), name);
+    if (fs10.existsSync(dest) && fs10.readdirSync(dest).length > 0) {
+      fail(`Directory not empty: ${dest}`);
+    }
+    if (source === "blank" || source === "git") {
+      let gitUrl = opts.git;
+      if (source === "git" && !gitUrl) {
+        gitUrl = (await text2({
+          message: "Git kit URL",
+          placeholder: "https://github.com/feeef/theme-blank.git",
+          validate: (v) => !v?.trim() ? "URL required" : void 0
+        })).trim();
+      }
+      const kit = await initFromBlank(dest, name, {
+        ...gitUrl ? { gitUrl } : {}
+      });
+      ok(`Created ${dest} (${kit.method}: ${kit.source})`);
+      info(
+        "Next:\n  cd " + name + "\n  feeef signin\n  feeef use\n  npm run build"
+      );
+      outro2("Theme scaffold ready");
+      return;
+    }
+    const { ff } = createClient({ requireAuth: false });
+    let templateId = opts.from;
+    if (!templateId) {
+      const picked = await pickPublicTemplateInteractive(ff, opts.search || "");
+      templateId = picked.id;
+      info(`Selected ${formatTemplateLabel(picked)}`);
+    }
+    const result = await initFromPublicTemplate(dest, name, templateId, ff);
+    ok(`Created ${dest} from \u201C${result.title}\u201D`);
+    if (result.localeCount > 0) {
+      info(`Wrote ${result.localeCount} locale file(s)`);
+    }
+    info(
+      "Next:\n  cd " + name + "\n  feeef signin\n  feeef use\n  npm run build\n  npm run dev"
+    );
+    outro2("Theme cloned and ready");
+  } catch (e) {
+    fail(e);
+  }
+}
+
+// src/commands/template/publish.ts
+import fs11 from "fs";
+import path13 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+
+// src/commands/use.ts
+var PAGE_SIZE2 = 20;
+var LOAD_MORE2 = "__load_more__";
+function formatStoreLabel(store) {
+  const title = store.name || store.slug || store.id;
+  if (store.slug && store.name && store.slug !== store.name) {
+    return `${store.name} (${store.slug})`;
+  }
+  return title;
+}
+async function pickStoreInteractive(ff) {
+  const me = await ff.users.me();
+  const userId = me.user?.id;
+  if (!userId) {
+    fail("Could not resolve the signed-in user. Run: feeef signin");
+  }
+  let page = 1;
+  const accumulated = [];
+  let total;
+  for (; ; ) {
+    const s = spinner2();
+    s.start(page === 1 ? "Loading your stores\u2026" : `Loading more (page ${page})\u2026`);
+    const res = await ff.stores.list({
+      page,
+      limit: PAGE_SIZE2,
+      userId
+    });
+    s.stop(page === 1 ? "Stores loaded" : "More stores loaded");
+    const batch = res.data || [];
+    if (typeof res.total === "number") total = res.total;
+    accumulated.push(...batch);
+    if (accumulated.length === 0) {
+      fail("No stores on this account");
+    }
+    const hasMore = batch.length >= PAGE_SIZE2 && (total == null || accumulated.length < total);
+    if (accumulated.length === 1 && !hasMore) {
+      return accumulated[0];
+    }
+    const options = [
+      ...accumulated.map((st) => ({
+        value: st.id,
+        label: formatStoreLabel(st),
+        hint: st.id
+      }))
+    ];
+    if (hasMore) {
+      const hint = total != null ? `${accumulated.length} of ${total}` : `loaded ${accumulated.length}`;
+      options.push({
+        value: LOAD_MORE2,
+        label: `${pc.dim("\u2192")} Load more\u2026`,
+        hint
+      });
+    }
+    const chosen = await select2({
+      message: "Pick a store",
+      options
+    });
+    if (chosen === LOAD_MORE2) {
+      page += 1;
+      continue;
+    }
+    const picked = accumulated.find((st) => st.id === chosen);
+    if (!picked) fail("Selected store not found");
+    return picked;
+  }
+}
+async function runUse(storeArg, opts) {
+  intro2("feeef use");
+  try {
+    const themeRoot = findThemeRoot(process.cwd());
+    if (!themeRoot) {
+      fail(
+        "No feeef.template.json nearby. Run from a theme folder or feeef template init first."
+      );
+    }
+    const { ff } = createClient();
+    let storeId;
+    let slug;
+    if (!storeArg) {
+      const picked = await pickStoreInteractive(ff);
+      storeId = picked.id;
+      slug = picked.slug;
+      if (slug || picked.name) {
+        info(`Selected ${formatStoreLabel(picked)}`);
+      }
+    } else {
+      try {
+        const bySlug = await ff.stores.find({ id: storeArg, by: "slug" });
+        storeId = bySlug.id;
+        slug = bySlug.slug;
+      } catch {
+        const byId = await ff.stores.find({ id: storeArg });
+        storeId = byId.id;
+        slug = byId.slug;
+      }
+    }
+    const patch = { store: storeId };
+    if (slug) patch.slug = slug;
+    if (opts.apiUrl) patch.apiUrl = opts.apiUrl;
+    const { rcPath } = saveProjectRc(themeRoot, patch);
+    saveConfig({ defaultStoreId: storeId });
+    ok(`Linked theme \u2192 store ${slug || storeId}`);
+    info(rcPath);
+    outro2("Next: feeef template publish --apply");
+  } catch (e) {
+    fail(e);
+  }
+}
+async function askApply(slug, force) {
+  if (force === true) return true;
+  if (force === false) return false;
+  return confirm2({
+    message: `Apply template to store "${slug}"?`,
+    initialValue: true
+  });
+}
+
+// src/commands/template/publish.ts
+var SOURCE_TAG_PREFIX = "feeef-source:";
+async function runTemplatePublish(dirArg, opts) {
+  intro2("feeef template publish");
+  try {
+    const { ff, http: http2, cfg } = createClient();
+    const srcDir = resolveThemeDir(dirArg);
+    const meta = loadTemplateMeta(srcDir);
+    const rc = loadProjectRc(srcDir);
+    const policy = opts.public ? "public" : opts.unlisted ? "unlisted" : "private";
+    let storeId = resolveStoreIdFromProject({
+      themeRoot: srcDir,
+      globalCfg: cfg,
+      ...opts.store ? { storeFlag: opts.store } : {}
+    });
+    if (!storeId) {
+      const listed = await ff.stores.list({ limit: 50 });
+      const stores = listed.data || [];
+      if (stores.length === 0) fail("No stores on this account");
+      if (stores.length === 1 || opts.yes) {
+        storeId = stores[0].id;
+      } else {
+        fail("No store linked. Run: feeef use <storeId|slug>");
+      }
+    }
+    const store = await ff.stores.find({ id: storeId });
+    const title = opts.title || rc.title || meta.name || path13.basename(srcDir);
+    info(`Theme  ${srcDir}`);
+    info(`Store  ${store.slug || storeId} (${policy})`);
+    const outPath = path13.join(srcDir, "dist", "data.json");
+    const s = spinner2();
+    s.start("Building\u2026");
+    const { buildTemplate } = await loadBuild();
+    const built = buildTemplate({ srcDir, outPath, write: true });
+    for (const w of built.warnings || []) {
+      warn(`[${w.path}] ${w.message}`);
+    }
+    s.stop(`Built (${built.localeCount ?? 0} locales)`);
+    const dataRaw = JSON.parse(fs11.readFileSync(outPath, "utf8"));
+    const i18n = dataRaw["i18n"];
+    const defaultLocale = i18n?.defaultLocale || (typeof meta.defaultLocale === "string" ? meta.defaultLocale : "en");
+    const distSchemaPath = path13.join(srcDir, "dist", "schema.json");
+    let schema;
+    if (fs11.existsSync(distSchemaPath)) {
+      schema = JSON.parse(fs11.readFileSync(distSchemaPath, "utf8"));
+    } else {
+      const { buildPackagedSchema } = await import(pathToFileURL2(
+        path13.join(cliRoot(), "vendor/template-kit/lib/theme-schema.mjs")
+      ).href);
+      const { schema: packed } = buildPackagedSchema({
+        srcDir,
+        libraryDoc: fs11.existsSync(path13.join(srcDir, "dist", "schema.library.json")) ? JSON.parse(
+          fs11.readFileSync(
+            path13.join(srcDir, "dist", "schema.library.json"),
+            "utf8"
+          )
+        ) : { components: [] }
+      });
+      schema = packed;
+    }
+    const libraryPath = path13.join(srcDir, "dist", "schema.library.json");
+    if (fs11.existsSync(libraryPath) && schema["library"] == null) {
+      const libDoc = JSON.parse(fs11.readFileSync(libraryPath, "utf8"));
+      schema = {
+        ...schema,
+        library: libDoc.library ?? libDoc.components ?? libDoc
+      };
+    }
+    if (typeof schema["name"] !== "string" || !schema["name"]) {
+      schema = { ...schema, name: title };
+    }
+    s.start("Publishing template_components\u2026");
+    const publishables = collectPublishableComponents(srcDir);
+    const codeToRefId = /* @__PURE__ */ new Map();
+    const sourceKeyToRefId = /* @__PURE__ */ new Map();
+    const existingList = await ff.templateComponents.list({
+      storeId,
+      limit: 200
+    });
+    const existingBySource = /* @__PURE__ */ new Map();
+    for (const row of existingList.data || []) {
+      const tag = (row.tags || []).find(
+        (t) => String(t).startsWith(SOURCE_TAG_PREFIX)
+      );
+      if (tag) {
+        existingBySource.set(
+          String(tag).slice(SOURCE_TAG_PREFIX.length),
+          row
+        );
+      }
+    }
+    for (const comp of publishables) {
+      const tags = [
+        ...Array.isArray(comp.meta["tags"]) ? comp.meta["tags"] : [],
+        `${SOURCE_TAG_PREFIX}${comp.sourceKey}`,
+        `feeef-kind:${comp.kind}`
+      ];
+      const payload = {
+        storeId,
+        title: comp.meta["title"] || comp.sourceKey,
+        subtitle: comp.meta["subtitle"] ?? null,
+        category: comp.meta["category"] ?? comp.kind,
+        tags,
+        imageUrl: comp.meta["imageUrl"] ?? null,
+        code: comp.code,
+        propsSchema: comp.meta["propsSchema"] || {},
+        slotsSchema: comp.meta["slotsSchema"] ?? null,
+        propsDefault: comp.meta["props"] || comp.meta["propsDefault"] || {},
+        slotsDefault: comp.meta["slotsDefault"] ?? null,
+        slotsLayout: comp.meta["slotsLayout"] ?? null,
+        policy,
+        price: 0
+      };
+      const existing = existingBySource.get(comp.sourceKey);
+      let row;
+      if (existing) {
+        row = await ff.templateComponents.update({
+          id: existing.id,
+          data: {
+            title: payload.title,
+            subtitle: payload.subtitle,
+            category: payload.category,
+            tags: payload.tags,
+            imageUrl: payload.imageUrl,
+            code: payload.code,
+            propsSchema: payload.propsSchema,
+            slotsSchema: payload.slotsSchema,
+            propsDefault: payload.propsDefault,
+            slotsDefault: payload.slotsDefault,
+            slotsLayout: payload.slotsLayout,
+            policy: payload.policy
+          }
+        });
+      } else {
+        row = await ff.templateComponents.create(payload);
+      }
+      codeToRefId.set(comp.code.trim(), row.id);
+      sourceKeyToRefId.set(comp.sourceKey, row.id);
+    }
+    s.stop(`${publishables.length} components`);
+    let data = rewriteDataToReferences(dataRaw, codeToRefId);
+    data = stripDataI18n(data);
+    if (Array.isArray(schema["library"])) {
+      schema["library"] = schema["library"].map(
+        (entry) => {
+          const key = entry["libraryId"] || entry["id"];
+          if (key && sourceKeyToRefId.has(key)) {
+            return { ...entry, refId: sourceKeyToRefId.get(key) };
+          }
+          return entry;
+        }
+      );
+    }
+    s.start("Publishing store_templates\u2026");
+    let templateId = rc.templateId || cfg.lastPublishedTemplateId || void 0;
+    let templateRow = null;
+    if (templateId) {
+      try {
+        templateRow = await ff.storeTemplates.find({ id: templateId });
+        if (templateRow && templateRow.storeId !== storeId) {
+          templateRow = null;
+          templateId = void 0;
+        }
+      } catch {
+        templateRow = null;
+        templateId = void 0;
+      }
+    }
+    if (!templateRow) {
+      const listed = await ff.storeTemplates.list({
+        storeId,
+        limit: 50,
+        q: title
+      });
+      templateRow = (listed.data || []).find(
+        (t) => t.storeId === storeId && t.title === title
+      ) || null;
+      templateId = templateRow?.id;
+    }
+    if (templateRow) {
+      templateRow = await ff.storeTemplates.update({
+        id: templateRow.id,
+        data: { title, schema, data, policy }
+      });
+      s.stop(`Updated ${templateRow.id}`);
+    } else {
+      templateRow = await ff.storeTemplates.create({
+        storeId,
+        title,
+        schema,
+        data,
+        policy,
+        price: 0
+      });
+      s.stop(`Created ${templateRow.id}`);
+    }
+    templateId = templateRow.id;
+    saveConfig({
+      defaultStoreId: storeId,
+      lastPublishedTemplateId: templateId
+    });
+    saveProjectRc(srcDir, {
+      store: storeId,
+      slug: store.slug,
+      templateId,
+      title
+    });
+    const locales = loadDistLocales(path13.join(srcDir, "dist"), defaultLocale);
+    if (locales.length) {
+      s.start(`Uploading ${locales.length} locales\u2026`);
+      if (typeof ff.storeTemplates.replaceLocales === "function") {
+        await ff.storeTemplates.replaceLocales(templateId, locales);
+      } else {
+        await http2.put(`/store_templates/${templateId}/locales`, { locales });
+      }
+      s.stop(`Locales: ${locales.map((l) => l.locale).join(", ")}`);
+    }
+    const shouldApply = opts.yes && opts.apply !== false ? true : await askApply(store.slug || storeId, opts.apply);
+    if (shouldApply) {
+      s.start("Installing on store\u2026");
+      await ff.storeTemplates.install({
+        fromId: templateId,
+        storeId
+      });
+      s.stop("Installed");
+      const preview = `https://${store.slug}.feeef.store`;
+      ok(`Preview ${pc.cyan(preview)}`);
+      outro2(preview);
+    } else {
+      ok(`Template id ${templateId}`);
+      outro2("Skipped install (use --apply next time)");
+    }
+  } catch (e) {
+    fail(e);
+  }
+}
+
+// src/commands/template/remove.ts
+import path14 from "path";
+async function runTemplateRemovePage(pageId, opts = {}) {
+  intro2("feeef template remove page");
+  try {
+    if (!pageId?.trim()) {
+      fail("Usage: feeef template remove page <pageId>");
+    }
+    const themeRoot = resolveThemeDir(opts.dir);
+    if (!opts.yes) {
+      const go = await confirm2({
+        message: `Delete pages/${pageId}/ and remove it from feeef.template.json?`,
+        initialValue: false
+      });
+      if (!go) {
+        outro2("Cancelled");
+        return;
+      }
+    }
+    const { pageId: id, removedPath } = removePage(themeRoot, pageId);
+    ok(`Removed ${path14.relative(themeRoot, removedPath)}`);
+    outro2(`Page "${id}" deleted`);
+  } catch (err) {
+    fail(err instanceof Error ? err.message : String(err));
+  }
+}
+async function runTemplateRemoveComponent(pageId, componentId, opts = {}) {
+  intro2("feeef template remove component");
+  try {
+    if (!pageId?.trim() || !componentId?.trim()) {
+      fail("Usage: feeef template remove component <pageId> <componentId>");
+    }
+    const themeRoot = resolveThemeDir(opts.dir);
+    if (!opts.yes) {
+      const go = await confirm2({
+        message: `Delete component ${pageId}/${componentId}?`,
+        initialValue: false
+      });
+      if (!go) {
+        outro2("Cancelled");
+        return;
+      }
+    }
+    const { removedPath } = removeComponent(themeRoot, pageId, componentId, {
+      ...opts.section ? { section: opts.section } : {}
+    });
+    ok(`Removed ${path14.relative(themeRoot, removedPath)}`);
+    outro2("Done");
+  } catch (err) {
+    fail(err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/commands/template/watch.ts
+import { spawn as spawn2 } from "child_process";
+import path15 from "path";
+async function runTemplateWatch(dirArg) {
+  intro2("feeef template watch");
+  try {
+    const srcDir = resolveThemeDir(dirArg);
+    const outPath = path15.join(srcDir, "dist", "data.json");
+    const s = spinner2();
+    s.start("Initial build\u2026");
+    const { buildTemplate } = await loadBuild();
+    buildTemplate({ srcDir, outPath, write: true });
+    s.stop(`Watching ${srcDir}`);
+    info(`Output \u2192 ${outPath}`);
+    info("Ctrl+C to stop");
+    const child = spawn2(
+      process.execPath,
+      [kitBin(), "watch", srcDir, "-o", outPath],
+      { stdio: "inherit" }
+    );
+    await new Promise((resolve, reject) => {
+      child.on("exit", (code) => {
+        if (code && code !== 0) reject(new Error(`watch exited ${code}`));
+        else resolve();
+      });
+    });
+    outro2("Stopped");
+  } catch (e) {
+    fail(e);
+  }
+}
+
+// src/index.ts
+function createProgram() {
+  const program = new Command();
+  program.name("feeef").description("Feeef developer CLI \u2014 themes today, cloud tools tomorrow").version("0.2.0").hook("preAction", (thisCommand) => {
+    if (thisCommand.args.length === 0) return;
+    banner();
+  });
+  program.command("signin").description("Sign in via browser OAuth (or --password-auth)").option("-e, --email <email>", "Account email (password auth)").option(
+    "--password-auth",
+    "Use email/password instead of browser OAuth (prompts for password)"
+  ).option("--api-url <url>", "API base URL").action(async (opts) => {
+    await runSignin({
+      email: opts.email,
+      apiUrl: opts.apiUrl,
+      passwordAuth: opts.passwordAuth
+    });
+  });
+  program.command("whoami").description("Show the signed-in user").action(async () => {
+    await runWhoami();
+  });
+  program.command("signout").description("Clear saved token").action(() => {
+    runSignout();
+  });
+  const config = program.command("config").description("Show or set CLI config (~/.config/feeef)");
+  config.command("show", { isDefault: true }).description("Print non-secret config").action(() => {
+    runConfigShow();
+  });
+  config.command("set").description("Set a config key").argument("<key>", "apiUrl | defaultStoreId | storefrontPath | devPort | \u2026").argument("<value>", "Value").action((key, value) => {
+    runConfigSet(key, value);
+  });
+  program.command("use").description(
+    "Link theme to a store (.feeefrc); omit store to pick from your list"
+  ).argument("[store]", "Store id or slug (optional \u2014 interactive picker)").option("--api-url <url>", "API override for this theme").action(async (store, opts) => {
+    await runUse(store, opts);
+  });
+  program.command("publish").description("Build + publish current theme (alias of template publish)").argument("[dir]", "Theme directory").option("--public", "Policy public (default private)").option("--unlisted", "Policy unlisted").option("--store <id>", "Owner store id").option("--title <title>", "Marketplace title").option("--yes", "Skip prompts").option("--apply", "Install onto the store").option("--no-apply", "Do not install").action(async (dir, opts) => {
+    await runTemplatePublish(dir, opts);
+  });
+  const template = program.command("template").description(
+    "Theme kit: init, add/remove page|component, build, check, watch, dev, publish"
+  );
+  template.command("init").description(
+    "Scaffold a theme (blank, git kit, or public marketplace)"
+  ).argument("[name]", "Folder name").option("--blank", "Use the blank scaffold (skip picker)").option("--from <templateId>", "Clone a public template by id").option("--git <url>", "Clone a kit repo (depth 1), Adonis/Laravel style").option("-q, --search <query>", "Pre-fill marketplace search").action(async (name, opts) => {
+    await runTemplateInit(name, {
+      blank: opts.blank,
+      from: opts.from,
+      search: opts.search,
+      git: opts.git
+    });
+  });
+  const templateAdd = template.command("add").description("Add a page or component to the current theme");
+  templateAdd.command("page").description("Create pages/<pageId>/ with flat components/ + update manifest").argument("<pageId>", "Page id (e.g. home, checkout, thank_you)").option("--dir <path>", "Theme directory").action(async (pageId, opts) => {
+    await runTemplateAddPage(pageId, { dir: opts.dir });
+  });
+  templateAdd.command("component").description(
+    "Create a starter <name>.tsx under pages/<page>/components/ (or sections/main)"
+  ).argument("<pageId>", "Page id").argument("<componentId>", "Component file id (e.g. hero)").option("--title <title>", "meta.title (default: Title Case of id)").option(
+    "--section <id>",
+    "Legacy: write under sections/<id>/components/ instead of flat"
+  ).option("--dir <path>", "Theme directory").action(async (pageId, componentId, opts) => {
+    await runTemplateAddComponent(pageId, componentId, {
+      dir: opts.dir,
+      title: opts.title,
+      section: opts.section
+    });
+  });
+  const templateRemove = template.command("remove").description("Remove a page or component from the current theme");
+  templateRemove.command("page").description("Delete pages/<pageId>/ and drop it from feeef.template.json").argument("<pageId>", "Page id").option("-y, --yes", "Skip confirmation").option("--dir <path>", "Theme directory").action(async (pageId, opts) => {
+    await runTemplateRemovePage(pageId, { dir: opts.dir, yes: opts.yes });
+  });
+  templateRemove.command("component").description("Delete a component file/folder under a page").argument("<pageId>", "Page id").argument("<componentId>", "Component id").option("--section <id>", "Legacy: only search sections/<id>/components/").option("-y, --yes", "Skip confirmation").option("--dir <path>", "Theme directory").action(async (pageId, componentId, opts) => {
+    await runTemplateRemoveComponent(pageId, componentId, {
+      dir: opts.dir,
+      section: opts.section,
+      yes: opts.yes
+    });
+  });
+  template.command("build").description("Compile theme \u2192 dist/data.json").argument("[dir]", "Theme directory").action(async (dir) => {
+    await runTemplateBuild(dir);
+  });
+  template.command("check").description("Validate theme without writing dist").argument("[dir]", "Theme directory").action(async (dir) => {
+    await runTemplateBuild(dir, { checkOnly: true });
+  });
+  template.command("watch").description("Rebuild on file changes").argument("[dir]", "Theme directory").action(async (dir) => {
+    await runTemplateWatch(dir);
+  });
+  template.command("dev").description(
+    "Watch + push draft preview to hosted storefront (never overwrites live theme)"
+  ).argument("[dir]", "Theme directory").option("-p, --port <port>", "Local Next port (only with --local)").option("--storefront <path>", "Lithium storefront root (implies --local)").option(
+    "--local",
+    "Employee escape hatch: spawn local Next (requires storefront)"
+  ).action(async (dir, opts) => {
+    await runTemplateDev(dir, opts);
+  });
+  template.command("publish").description("Build, upload components + template + locales, optional install").argument("[dir]", "Theme directory").option("--public", "Policy public (default private)").option("--unlisted", "Policy unlisted").option("--store <id>", "Owner store id").option("--title <title>", "Marketplace title").option("--yes", "Skip prompts").option("--apply", "Install onto the store").option("--no-apply", "Do not install").action(async (dir, opts) => {
+    await runTemplatePublish(dir, opts);
+  });
+  const cloud = program.command("cloud").description("Cloud providers (Azure / GCP / AWS) \u2014 coming soon");
+  cloud.command("azure").description("Azure helpers (coming soon)").action(() => {
+    console.log(pc.dim("Not implemented yet. Tracked for a future release."));
+  });
+  cloud.command("gcp").description("Google Cloud helpers (coming soon)").action(() => {
+    console.log(pc.dim("Not implemented yet."));
+  });
+  cloud.command("aws").description("AWS helpers (coming soon)").action(() => {
+    console.log(pc.dim("Not implemented yet."));
+  });
+  return program;
+}
+async function runCli(argv = process.argv) {
+  const program = createProgram();
+  await program.parseAsync(argv);
+}
+export {
+  createProgram,
+  runCli
+};
+//# sourceMappingURL=index.js.map