@emailshepherd/cli 0.1.22

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,704 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import "dotenv/config";
+import { Command } from "commander";
+
+// package.json
+var version = "0.1.22";
+
+// src/commands/init.ts
+import { AxiosError } from "axios";
+import { existsSync, mkdirSync as mkdirSync2, rmSync, writeFileSync as writeFileSync2, readFileSync, readdirSync, statSync } from "fs";
+import { resolve as resolve2, dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+import { input, password, select } from "@inquirer/prompts";
+
+// src/api/axiosConfig.ts
+import axios from "axios";
+function configureAxios(config) {
+  const baseUrl = config?.baseUrl ?? process.env.EMAILSHEPHERD_BASE_URL ?? "https://api.emailshepherd.com";
+  const apiKey = config?.apiKey ?? process.env.EMAILSHEPHERD_API_KEY;
+  axios.defaults.baseURL = baseUrl;
+  axios.defaults.headers.common["Authorization"] = `Bearer ${apiKey}`;
+  axios.defaults.headers.common["Content-Type"] = "application/json";
+}
+
+// src/api/generated/apiV1.ts
+import axios2 from "axios";
+var getEmailDesignSystems = (workspaceId, params, options) => {
+  return axios2.get(
+    `/api/v1/workspaces/${workspaceId}/email_design_systems`,
+    {
+      ...options,
+      params: { ...params, ...options?.params }
+    }
+  );
+};
+var getEmailDesignSystem = (workspaceId, id, options) => {
+  return axios2.get(
+    `/api/v1/workspaces/${workspaceId}/email_design_systems/${id}`,
+    options
+  );
+};
+var updateEmailDesignSystem = (workspaceId, id, updateEmailDesignSystemBody, options) => {
+  return axios2.patch(
+    `/api/v1/workspaces/${workspaceId}/email_design_systems/${id}`,
+    updateEmailDesignSystemBody,
+    options
+  );
+};
+var renderEmailDesignSystem = (workspaceId, emailDesignSystemId, renderEmailDesignSystemBody, options) => {
+  return axios2.post(
+    `/api/v1/workspaces/${workspaceId}/email_design_systems/${emailDesignSystemId}/renders`,
+    renderEmailDesignSystemBody,
+    options
+  );
+};
+var getComponents = (workspaceId, emailDesignSystemId, params, options) => {
+  return axios2.get(
+    `/api/v1/workspaces/${workspaceId}/email_design_systems/${emailDesignSystemId}/components`,
+    {
+      ...options,
+      params: { ...params, ...options?.params }
+    }
+  );
+};
+var createComponent = (workspaceId, emailDesignSystemId, createComponentBody, options) => {
+  return axios2.post(
+    `/api/v1/workspaces/${workspaceId}/email_design_systems/${emailDesignSystemId}/components`,
+    createComponentBody,
+    options
+  );
+};
+var updateComponent = (workspaceId, emailDesignSystemId, id, updateComponentBody, options) => {
+  return axios2.patch(
+    `/api/v1/workspaces/${workspaceId}/email_design_systems/${emailDesignSystemId}/components/${id}`,
+    updateComponentBody,
+    options
+  );
+};
+var getWorkspaces = (params, options) => {
+  return axios2.get(
+    `/api/v1/workspaces`,
+    {
+      ...options,
+      params: { ...params, ...options?.params }
+    }
+  );
+};
+
+// src/utils/componentFiles.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { resolve } from "path";
+var EXCLUDED_FIELDS = [
+  "email_design_system_id",
+  "last_updated_by",
+  "updated_at",
+  "created_at",
+  "screenshot_url",
+  "template",
+  "container",
+  "position"
+];
+function cleanComponentForConfig(component) {
+  const cleaned = {};
+  for (const [key, value] of Object.entries(component)) {
+    if (!EXCLUDED_FIELDS.includes(key)) {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}
+function writeComponentFiles(component, directory) {
+  writeFileSync(resolve(directory, "template.liquid"), component.template);
+  const cleanedComponent = cleanComponentForConfig(component);
+  const componentWithTemplate = { ...cleanedComponent, template: "TEMPLATE_PLACEHOLDER" };
+  const jsonString = JSON.stringify(componentWithTemplate, null, 2).replace('"TEMPLATE_PLACEHOLDER"', "template");
+  const componentContent = `import { defineComponent } from '@emailshepherd/cli/types';
+import template from './template.liquid?raw';
+
+export default defineComponent(${jsonString});
+`;
+  writeFileSync(resolve(directory, "index.ts"), componentContent);
+}
+function buildComponentDirectory(component, targetDir) {
+  const componentDirectory = resolve(targetDir, "src", "components", component.name);
+  mkdirSync(componentDirectory, { recursive: true });
+  writeComponentFiles(component, componentDirectory);
+}
+
+// src/commands/init.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var TEMPLATES_DIR = join(__dirname, "..", "templates");
+var BASE_URL = "https://api.emailshepherd.com";
+function buildContainerComponentDirectory(component, targetDir) {
+  const containerDir = resolve2(targetDir, "src", "container_component");
+  writeComponentFiles(component, containerDir);
+}
+function copyTemplates(targetDir, replacements) {
+  const templatesDir = TEMPLATES_DIR;
+  const files = readdirSync(templatesDir);
+  for (const file of files) {
+    const sourcePath = join(templatesDir, file);
+    const isDir = statSync(sourcePath).isDirectory();
+    if (isDir && file === "claude") {
+      const destDir = join(targetDir, ".claude");
+      mkdirSync2(destDir, { recursive: true });
+      for (const subFile of readdirSync(sourcePath)) {
+        const subSource = join(sourcePath, subFile);
+        const subDest = join(destDir, subFile);
+        let content2 = readFileSync(subSource, "utf-8");
+        for (const [placeholder, value] of Object.entries(replacements)) {
+          content2 = content2.replace(new RegExp(`\\{\\{${placeholder}\\}\\}`, "g"), value);
+        }
+        writeFileSync2(subDest, content2);
+      }
+      continue;
+    }
+    if (isDir) {
+      continue;
+    }
+    const destFile = file === "gitignore" ? ".gitignore" : file;
+    const destPath = join(targetDir, destFile);
+    let content = readFileSync(sourcePath, "utf-8");
+    for (const [placeholder, value] of Object.entries(replacements)) {
+      content = content.replace(new RegExp(`\\{\\{${placeholder}\\}\\}`, "g"), value);
+    }
+    writeFileSync2(destPath, content);
+  }
+}
+async function bootstrapProject({ workspaceId, edsId, targetDir, projectName, apiKey }) {
+  if (!existsSync(targetDir)) {
+    mkdirSync2(targetDir, { recursive: true });
+  }
+  copyTemplates(targetDir, {
+    PROJECT_NAME: projectName
+  });
+  const edsResponse = await getEmailDesignSystem(workspaceId, edsId);
+  const edsData = edsResponse.data;
+  const componentsResponse = await getComponents(workspaceId, edsId);
+  const componentsData = componentsResponse.data;
+  const containerComponent = componentsData.results.find((c) => c.container);
+  const regularComponents = componentsData.results.filter((c) => !c.container);
+  if (!containerComponent) {
+    throw new Error("No container component found in the Email Design System");
+  }
+  if (existsSync(resolve2(targetDir, "src"))) {
+    rmSync(resolve2(targetDir, "src"), { recursive: true });
+  }
+  mkdirSync2(resolve2(targetDir, "src"), { recursive: true });
+  mkdirSync2(resolve2(targetDir, "src", "components"), { recursive: true });
+  mkdirSync2(resolve2(targetDir, "src", "container_component"), { recursive: true });
+  const viteEnvSource = join(TEMPLATES_DIR, "src", "vite-env.d.ts");
+  const viteEnvDest = resolve2(targetDir, "src", "vite-env.d.ts");
+  writeFileSync2(viteEnvDest, readFileSync(viteEnvSource, "utf-8"));
+  buildContainerComponentDirectory(containerComponent, targetDir);
+  for (const component of regularComponents) {
+    buildComponentDirectory(component, targetDir);
+  }
+  const componentsIndexContent = `import type { ComponentDefinition } from '@emailshepherd/cli/types';
+
+const modules = import.meta.glob<{ default: ComponentDefinition }>('./*/index.ts', { eager: true });
+
+export default Object.values(modules).map((m) => m.default);
+`;
+  writeFileSync2(resolve2(targetDir, "src", "components", "index.ts"), componentsIndexContent);
+  const designTokensContent = `import { defineDesignTokens } from '@emailshepherd/cli/types';
+
+export default defineDesignTokens(${JSON.stringify(edsData.design_tokens || {}, null, 2)});
+`;
+  writeFileSync2(resolve2(targetDir, "src", "design_tokens.ts"), designTokensContent);
+  const customStylesContent = `import { defineCustomStyles } from '@emailshepherd/cli/types';
+
+export default defineCustomStyles(${JSON.stringify(edsData.custom_styles || [], null, 2)});
+`;
+  writeFileSync2(resolve2(targetDir, "src", "custom_styles.ts"), customStylesContent);
+  const edsContent = `import { defineEDS } from '@emailshepherd/cli/types';
+import designTokens from './design_tokens';
+import customStyles from './custom_styles';
+import containerComponent from './container_component';
+import components from './components';
+
+export default defineEDS({
+  workspace_id: ${workspaceId},
+  email_design_system_id: ${edsId},
+  eds_metadata: {
+    name: ${JSON.stringify(edsData.name)},
+    design_tokens: designTokens,
+    custom_styles: customStyles,
+  },
+  container_component: containerComponent,
+  components,
+});
+`;
+  writeFileSync2(resolve2(targetDir, "src", "eds.ts"), edsContent);
+  const envContent = `EMAILSHEPHERD_API_KEY=${apiKey ?? "your_api_key_here"}
+EMAILSHEPHERD_BASE_URL=${BASE_URL}
+`;
+  writeFileSync2(resolve2(targetDir, ".env"), envContent);
+  console.log("Installing dependencies...");
+  execSync("npm install", { cwd: targetDir, stdio: "inherit" });
+  try {
+    execSync("git init", { cwd: targetDir, stdio: "ignore" });
+    execSync("git add .", { cwd: targetDir, stdio: "ignore" });
+    execSync('git commit -m "Initial commit from EmailShepherd CLI"', { cwd: targetDir, stdio: "ignore" });
+  } catch {
+  }
+  return { edsName: edsData.name };
+}
+function registerInitCommand(program2) {
+  program2.command("init").description("Interactively initialize a new Email Design System project").action(async () => {
+    try {
+      console.log("\n\u{1F4E7} Welcome to EmailShepherd CLI\n");
+      const apiKey = await password({
+        message: "Enter your EmailShepherd API Key:",
+        mask: "*"
+      });
+      configureAxios({ apiKey, baseUrl: BASE_URL });
+      const workspacesResponse = await getWorkspaces();
+      const workspaces = workspacesResponse.data.results;
+      if (workspaces.length === 0) {
+        console.error("No workspaces found for this API key.");
+        process.exit(1);
+      }
+      const workspaceId = await select({
+        message: "Select a workspace:",
+        choices: workspaces.map((ws) => ({
+          name: ws.name,
+          value: ws.id,
+          description: `ID: ${ws.id}`
+        }))
+      });
+      console.log("\nFetching email design systems...");
+      const edsResponse = await getEmailDesignSystems(workspaceId);
+      const emailDesignSystems = edsResponse.data.results;
+      if (emailDesignSystems.length === 0) {
+        console.error("No email design systems found in this workspace.");
+        process.exit(1);
+      }
+      const edsId = await select({
+        message: "Select an Email Design System:",
+        choices: emailDesignSystems.map((eds) => ({
+          name: eds.name,
+          value: eds.id,
+          description: eds.description || `ID: ${eds.id}`
+        }))
+      });
+      const selectedEds = emailDesignSystems.find((eds) => eds.id === edsId);
+      const suggestedDirName = selectedEds?.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+      const dirName = await input({
+        message: "Enter the project directory name:",
+        default: suggestedDirName,
+        validate: (value) => {
+          if (!value.trim()) return "Directory name is required";
+          if (existsSync(resolve2(process.cwd(), value))) {
+            return `Directory "${value}" already exists. Choose a different name.`;
+          }
+          return true;
+        }
+      });
+      const targetDir = resolve2(process.cwd(), dirName);
+      console.log("\nBootstrapping your project...");
+      const { edsName } = await bootstrapProject({
+        workspaceId,
+        edsId,
+        targetDir,
+        projectName: dirName,
+        apiKey
+      });
+      console.log(`
+\u2705 Project "${edsName}" initialized successfully!`);
+      console.log(`
+Next steps:`);
+      console.log(`  cd ${dirName}`);
+      console.log(`  npx emailshepherd dev`);
+      console.log("");
+    } catch (error) {
+      if (error instanceof AxiosError && error.response?.data) {
+        console.error("\nAPI Error:", JSON.stringify(error.response.data, null, 2));
+      } else if (error instanceof Error) {
+        if (error.message.includes("User force closed")) {
+          console.log("\n\nSetup cancelled.");
+          process.exit(0);
+        }
+        console.error("\nError:", error.message);
+      } else {
+        console.error("\nError:", error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/validate.ts
+import { AxiosError as AxiosError3 } from "axios";
+
+// src/buildHtml.ts
+import { AxiosError as AxiosError2 } from "axios";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+import { createServer } from "vite";
+var viteServer = null;
+async function getViteServer() {
+  if (!viteServer) {
+    viteServer = await createServer({
+      root: process.cwd(),
+      server: { middlewareMode: true },
+      appType: "custom",
+      logLevel: "silent"
+    });
+  }
+  return viteServer;
+}
+function renderErrorHtml(title, message, details) {
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Email Shepherd - Error</title>
+    <style>
+      body {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+        background: #1a1a1a;
+        color: #e0e0e0;
+        padding: 40px;
+        margin: 0;
+      }
+      .error-container {
+        max-width: 800px;
+        margin: 0 auto;
+      }
+      h1 {
+        color: #ff6b6b;
+        margin-bottom: 8px;
+      }
+      .status {
+        color: #888;
+        margin-bottom: 24px;
+      }
+      pre {
+        background: #2a2a2a;
+        border: 1px solid #444;
+        border-radius: 8px;
+        padding: 20px;
+        overflow-x: auto;
+        font-size: 14px;
+        line-height: 1.5;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="error-container">
+      <h1>${title}</h1>
+      <p class="status">${message}</p>
+      <pre>${typeof details === "string" ? details : JSON.stringify(details, null, 2)}</pre>
+    </div>
+  </body>
+</html>`;
+}
+var loadEDS = async () => {
+  const edsPath = resolve3(process.cwd(), "src", "eds.ts");
+  if (!existsSync2(edsPath)) {
+    throw new Error(`Missing src/eds.ts - this file defines your Email Design System configuration.`);
+  }
+  const server = await getViteServer();
+  const edsModule = await server.ssrLoadModule(edsPath);
+  return edsModule.default;
+};
+var buildEmailDesignSystemObject = async (eds) => {
+  return {
+    email_design_system: {
+      design_tokens: eds.eds_metadata.design_tokens,
+      custom_styles: eds.eds_metadata.custom_styles || []
+    },
+    container_component: eds.container_component,
+    components: eds.components
+  };
+};
+function writeHtml(html) {
+  const distDir = resolve3(process.cwd(), "dist");
+  mkdirSync3(distDir, { recursive: true });
+  writeFileSync3(resolve3(distDir, "index.html"), html);
+}
+async function buildHtml() {
+  configureAxios();
+  let html;
+  try {
+    const eds = await loadEDS();
+    const objectRepresentation = await buildEmailDesignSystemObject(eds);
+    const response = await renderEmailDesignSystem(
+      eds.workspace_id,
+      eds.email_design_system_id,
+      objectRepresentation
+    );
+    if (response.data.html) {
+      html = response.data.html;
+    } else {
+      html = renderErrorHtml("API Error", "No HTML returned", response.data);
+    }
+  } catch (error) {
+    if (error instanceof AxiosError2) {
+      const status = error.response?.status ?? "Unknown";
+      const statusText = error.response?.statusText ?? error.message;
+      html = renderErrorHtml("API Error", `Status: ${status} ${statusText}`, error.response?.data ?? error.message);
+    } else if (error instanceof Error) {
+      html = renderErrorHtml("Error", error.message, error.stack ?? "");
+    } else {
+      html = renderErrorHtml("Error", "Unknown error", error);
+    }
+  }
+  writeHtml(html);
+  return html;
+}
+
+// src/loadEDS.ts
+import { build } from "vite";
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve4 } from "path";
+async function loadEDS2() {
+  const edsPath = resolve4(process.cwd(), "src", "eds.ts");
+  if (!existsSync3(edsPath)) {
+    throw new Error("Missing src/eds.ts - this file defines your Email Design System configuration.");
+  }
+  const result = await build({
+    root: process.cwd(),
+    logLevel: "silent",
+    build: {
+      write: false,
+      lib: {
+        entry: edsPath,
+        formats: ["es"]
+      }
+    }
+  });
+  const output = Array.isArray(result) ? result[0] : result;
+  const chunk = output.output.find((o) => o.type === "chunk");
+  if (!chunk) {
+    throw new Error("Failed to bundle EDS");
+  }
+  const dataUrl = `data:text/javascript;base64,${Buffer.from(chunk.code).toString("base64")}`;
+  const module = await import(dataUrl);
+  return module.default;
+}
+
+// src/commands/validate.ts
+function registerValidateCommand(program2) {
+  program2.command("validate").description("Validate the Email Design System").action(async () => {
+    try {
+      configureAxios();
+      const eds = await loadEDS2();
+      const objectRepresentation = await buildEmailDesignSystemObject(eds);
+      const response = await renderEmailDesignSystem(
+        eds.workspace_id,
+        eds.email_design_system_id,
+        objectRepresentation
+      );
+      if (response.data.html) {
+        console.log("No validation errors");
+      } else {
+        console.log(JSON.stringify(response.data, null, 2));
+        process.exit(1);
+      }
+    } catch (error) {
+      if (error instanceof AxiosError3 && error.response?.data) {
+        console.log(JSON.stringify(error.response.data, null, 2));
+      } else if (error instanceof Error) {
+        console.error(error.message);
+      } else {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/save-component.ts
+import { AxiosError as AxiosError4 } from "axios";
+function registerSaveComponentCommand(program2) {
+  program2.command("save-component").description("Save a component to the server").option("--by-name <name>", "Component name to save").option("--by-id <id>", "Component ID to save").action(async (options) => {
+    try {
+      if (!options.byName && !options.byId) {
+        console.error("Error: Either --by-name or --by-id is required");
+        process.exit(1);
+      }
+      configureAxios();
+      const eds = await loadEDS2();
+      const component = eds.container_component.id === Number(options.byId) || eds.container_component.name === options.byName ? eds.container_component : eds.components.find(
+        (c) => options.byId ? c.id === Number(options.byId) : c.name === options.byName
+      );
+      if (!component) {
+        console.error(`Error: Component not found${options.byName ? ` with name "${options.byName}"` : ` with id ${options.byId}`}`);
+        process.exit(1);
+      }
+      const response = await updateComponent(
+        eds.workspace_id,
+        eds.email_design_system_id,
+        component.id,
+        component
+      );
+      console.log(`Component "${response.data.name}" saved successfully`);
+    } catch (error) {
+      if (error instanceof AxiosError4 && error.response?.data) {
+        console.log(JSON.stringify(error.response.data, null, 2));
+      } else if (error instanceof Error) {
+        console.error(error.message);
+      } else {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/save-eds.ts
+import { AxiosError as AxiosError5 } from "axios";
+function registerSaveEDSCommand(program2) {
+  program2.command("save-eds").description("Save the Email Design System metadata to the server").action(async () => {
+    try {
+      configureAxios();
+      const eds = await loadEDS2();
+      const response = await updateEmailDesignSystem(
+        eds.workspace_id,
+        eds.email_design_system_id,
+        {
+          name: eds.eds_metadata.name,
+          design_tokens: eds.eds_metadata.design_tokens,
+          custom_styles: eds.eds_metadata.custom_styles
+        }
+      );
+      console.log(`Email Design System "${response.data.name}" saved successfully`);
+    } catch (error) {
+      if (error instanceof AxiosError5 && error.response?.data) {
+        console.log(JSON.stringify(error.response.data, null, 2));
+      } else if (error instanceof Error) {
+        console.error(error.message);
+      } else {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/save-all.ts
+import { AxiosError as AxiosError6 } from "axios";
+function registerSaveAllCommand(program2) {
+  program2.command("save-all").description("Save the Email Design System and all components to the server").action(async () => {
+    try {
+      configureAxios();
+      const eds = await loadEDS2();
+      console.log("Saving Email Design System...");
+      const edsResponse = await updateEmailDesignSystem(
+        eds.workspace_id,
+        eds.email_design_system_id,
+        {
+          name: eds.eds_metadata.name,
+          design_tokens: eds.eds_metadata.design_tokens,
+          custom_styles: eds.eds_metadata.custom_styles
+        }
+      );
+      console.log(`Email Design System "${edsResponse.data.name}" saved successfully`);
+      console.log(`Saving container component "${eds.container_component.name}"...`);
+      const containerResponse = await updateComponent(
+        eds.workspace_id,
+        eds.email_design_system_id,
+        eds.container_component.id,
+        eds.container_component
+      );
+      console.log(`Container component "${containerResponse.data.name}" saved successfully`);
+      for (const component of eds.components) {
+        console.log(`Saving component "${component.name}"...`);
+        const response = await updateComponent(
+          eds.workspace_id,
+          eds.email_design_system_id,
+          component.id,
+          component
+        );
+        console.log(`Component "${response.data.name}" saved successfully`);
+      }
+      console.log("All saved successfully");
+    } catch (error) {
+      if (error instanceof AxiosError6 && error.response?.data) {
+        console.log(JSON.stringify(error.response.data, null, 2));
+      } else if (error instanceof Error) {
+        console.error(error.message);
+      } else {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/dev.ts
+import { createServer as createServer2 } from "vite";
+import chokidar from "chokidar";
+function registerDevCommand(program2) {
+  program2.command("dev").description("Start the development server with hot reload").option("-p, --port <port>", "Port to run the server on", "5173").action(async (options) => {
+    const port = parseInt(options.port, 10);
+    console.log("Building...");
+    await buildHtml();
+    const server = await createServer2({
+      root: "dist",
+      server: { port }
+    });
+    const watcher = chokidar.watch("src", { ignoreInitial: true, usePolling: true, interval: 300 });
+    watcher.on("all", async (event, path) => {
+      console.log(`[src] ${event}: ${path}, rebuilding...`);
+      await buildHtml();
+      server.ws.send({ type: "full-reload" });
+    });
+    await server.listen();
+    server.printUrls();
+  });
+}
+
+// src/commands/create-component.ts
+import { AxiosError as AxiosError7 } from "axios";
+function registerCreateComponentCommand(program2) {
+  program2.command("create-component").description("Create a new component in the Email Design System").requiredOption("--name <name>", "Component name (used as directory name and in code)").requiredOption("--label <label>", "Component label (displayed in the UI)").action(async (options) => {
+    try {
+      configureAxios();
+      const eds = await loadEDS2();
+      const response = await createComponent(
+        eds.workspace_id,
+        eds.email_design_system_id,
+        {
+          name: options.name,
+          label: options.label,
+          template: "<div>Hello, world!</div>",
+          field_definitions: []
+        }
+      );
+      const component = response.data;
+      const targetDir = process.cwd();
+      buildComponentDirectory(component, targetDir);
+      console.log(`Component "${component.name}" created successfully`);
+    } catch (error) {
+      if (error instanceof AxiosError7 && error.response?.data) {
+        console.log(JSON.stringify(error.response.data, null, 2));
+      } else if (error instanceof Error) {
+        console.error(error.message);
+      } else {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("emailshepherd").description("EmailShepherd CLI").version(version);
+registerInitCommand(program);
+registerValidateCommand(program);
+registerSaveComponentCommand(program);
+registerCreateComponentCommand(program);
+registerSaveEDSCommand(program);
+registerSaveAllCommand(program);
+registerDevCommand(program);
+program.parse();