npm - emailr-cli - Versions diffs - 1.1.0 → 1.2.0 - Mend

emailr-cli 1.1.0 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +740 -14
package/package.json +16 -12

package/dist/index.js CHANGED Viewed

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // src/index.ts
-import { Command as Command9 } from "commander";
+import { Command as Command10 } from "commander";
 // src/commands/send.ts
 import { Command } from "commander";
@@ -142,6 +142,9 @@ function success(message) {
 function error(message) {
   console.error(chalk.red("\u2717"), message);
 }
+function warn(message) {
+  console.warn(chalk.yellow("\u26A0"), message);
+}
 function info(message) {
   console.log(chalk.blue("\u2139"), message);
 }
@@ -340,6 +343,309 @@ Total: ${result.total}`);
 // src/commands/templates.ts
 import { Command as Command3 } from "commander";
 import { Emailr as Emailr3 } from "emailr";
+// src/server/template-store.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+function getTemplatesDir() {
+  return path2.join(os2.homedir(), ".config", "emailr", "templates");
+}
+function ensureTemplatesDir() {
+  const templatesDir = getTemplatesDir();
+  if (!fs2.existsSync(templatesDir)) {
+    fs2.mkdirSync(templatesDir, { recursive: true });
+  }
+}
+function getTemplatePath(templateId) {
+  return path2.join(getTemplatesDir(), `${templateId}.html`);
+}
+function saveTemplate(templateId, htmlContent) {
+  ensureTemplatesDir();
+  const templatePath = getTemplatePath(templateId);
+  fs2.writeFileSync(templatePath, htmlContent, "utf-8");
+}
+function readTemplate(templateId) {
+  const templatePath = getTemplatePath(templateId);
+  if (!fs2.existsSync(templatePath)) {
+    return null;
+  }
+  return fs2.readFileSync(templatePath, "utf-8");
+}
+function templateExists(templateId) {
+  const templatePath = getTemplatePath(templateId);
+  return fs2.existsSync(templatePath);
+}
+// src/server/preview-server.ts
+import http from "http";
+var serverInstance = null;
+var serverPort = null;
+var serverRunning = false;
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function isEmptyContent(content) {
+  return content === null || content.trim() === "";
+}
+function generateEmptyContentPlaceholder(templateId) {
+  const escapedId = escapeHtml(templateId);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>No Content - Emailr CLI</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: #fff;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 16px;
+      backdrop-filter: blur(10px);
+      max-width: 500px;
+    }
+    .icon {
+      font-size: 4rem;
+      margin-bottom: 1rem;
+    }
+    h1 {
+      margin: 0 0 1rem 0;
+      font-size: 1.5rem;
+    }
+    p {
+      margin: 0;
+      opacity: 0.9;
+      line-height: 1.6;
+    }
+    .template-id {
+      margin-top: 1rem;
+      padding: 1rem;
+      background: rgba(0, 0, 0, 0.2);
+      border-radius: 8px;
+      font-size: 0.9rem;
+      font-family: monospace;
+    }
+    .hint {
+      margin-top: 1.5rem;
+      padding: 1rem;
+      background: rgba(255, 255, 255, 0.15);
+      border-radius: 8px;
+      font-size: 0.85rem;
+    }
+    code {
+      background: rgba(0, 0, 0, 0.2);
+      padding: 0.2rem 0.4rem;
+      border-radius: 4px;
+      font-family: monospace;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="icon">\u{1F4ED}</div>
+    <h1>No Content Available</h1>
+    <p>This template exists but has no HTML content to display.</p>
+    <div class="template-id">${escapedId}</div>
+    <div class="hint">
+      <p><strong>To add content:</strong></p>
+      <p>Update the template using the CLI with the <code>--html</code> option or provide HTML content when creating the template.</p>
+    </div>
+  </div>
+</body>
+</html>`;
+}
+function generateNotFoundHtml(templateId) {
+  const escapedId = escapeHtml(templateId);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Template Not Found - Emailr CLI</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+      color: #fff;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 16px;
+      backdrop-filter: blur(10px);
+      max-width: 400px;
+    }
+    .icon {
+      font-size: 4rem;
+      margin-bottom: 1rem;
+    }
+    h1 {
+      margin: 0 0 1rem 0;
+      font-size: 1.5rem;
+    }
+    p {
+      margin: 0;
+      opacity: 0.9;
+    }
+    .template-id {
+      margin-top: 1rem;
+      padding: 1rem;
+      background: rgba(0, 0, 0, 0.2);
+      border-radius: 8px;
+      font-size: 0.9rem;
+      font-family: monospace;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="icon">404</div>
+    <h1>Template Not Found</h1>
+    <p>The requested template could not be found in local storage.</p>
+    <div class="template-id">${escapedId}</div>
+    <p style="margin-top: 1rem;">Try creating or retrieving the template first using the CLI.</p>
+  </div>
+</body>
+</html>`;
+}
+function parseTemplateIdFromPath(urlPath) {
+  const match = urlPath.match(/^\/preview\/([^/]+)$/);
+  return match ? match[1] : null;
+}
+function createRequestHandler() {
+  return (req, res) => {
+    if (req.method !== "GET") {
+      res.writeHead(405, { "Content-Type": "text/plain" });
+      res.end("Method Not Allowed");
+      return;
+    }
+    const urlPath = req.url || "/";
+    const templateId = parseTemplateIdFromPath(urlPath);
+    if (!templateId) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+      return;
+    }
+    if (!templateExists(templateId)) {
+      res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(generateNotFoundHtml(templateId));
+      return;
+    }
+    const htmlContent = readTemplate(templateId);
+    if (htmlContent === null) {
+      res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(generateNotFoundHtml(templateId));
+      return;
+    }
+    if (isEmptyContent(htmlContent)) {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(generateEmptyContentPlaceholder(templateId));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(htmlContent);
+  };
+}
+var previewServer = {
+  async start() {
+    if (serverRunning && serverPort !== null) {
+      return serverPort;
+    }
+    return new Promise((resolve, reject) => {
+      serverInstance = http.createServer(createRequestHandler());
+      serverInstance.listen(0, "127.0.0.1", () => {
+        const address = serverInstance.address();
+        if (address && typeof address === "object") {
+          serverPort = address.port;
+          serverRunning = true;
+          serverInstance.unref();
+          resolve(serverPort);
+        } else {
+          reject(new Error("Failed to get server address"));
+        }
+      });
+      serverInstance.on("error", (err) => {
+        serverRunning = false;
+        serverPort = null;
+        serverInstance = null;
+        reject(new Error(`Failed to start preview server: ${err.message}`));
+      });
+    });
+  },
+  getPort() {
+    return serverPort;
+  },
+  isRunning() {
+    return serverRunning;
+  },
+  async stop() {
+    if (serverInstance) {
+      return new Promise((resolve) => {
+        serverInstance.close(() => {
+          serverInstance = null;
+          serverPort = null;
+          serverRunning = false;
+          resolve();
+        });
+      });
+    }
+  }
+};
+function getPreviewServer() {
+  return previewServer;
+}
+async function getPreviewUrl(templateId) {
+  try {
+    const port = await previewServer.start();
+    return `http://127.0.0.1:${port}/preview/${templateId}`;
+  } catch {
+    return null;
+  }
+}
+function keepServerAlive() {
+  if (serverInstance) {
+    serverInstance.ref();
+  }
+}
+// src/commands/templates.ts
+async function handleTemplatePreview(template) {
+  try {
+    const htmlContent = template.html_content ?? "";
+    saveTemplate(template.id, htmlContent);
+  } catch (err) {
+    warn(`Could not save template for preview: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+  try {
+    const previewUrl = await getPreviewUrl(template.id);
+    if (previewUrl === null) {
+      warn("Could not start preview server");
+      return null;
+    }
+    return previewUrl;
+  } catch (err) {
+    warn(`Could not generate preview URL: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
 function createTemplatesCommand() {
   const cmd = new Command3("templates").description("Manage email templates");
   cmd.command("list").description("List all templates").option("--limit <number>", "Number of templates to return", "20").option("--page <number>", "Page number", "1").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
@@ -380,7 +686,28 @@ Total: ${result.length}`);
         baseUrl: config.baseUrl
       });
       const template = await client.templates.get(id);
-      output(template, options.format);
+      const previewUrl = await handleTemplatePreview({
+        id: template.id,
+        html_content: template.html_content ?? void 0
+      });
+      if (options.format === "json") {
+        output({
+          ...template,
+          preview_url: previewUrl
+        }, "json");
+      } else {
+        const tableData = {
+          ID: template.id,
+          Name: template.name,
+          Subject: template.subject,
+          Variables: template.variables?.join(", ") || "-",
+          Created: template.created_at
+        };
+        if (previewUrl) {
+          tableData["Preview URL"] = previewUrl;
+        }
+        output(tableData, "table");
+      }
     } catch (err) {
       error(err instanceof Error ? err.message : "Failed to get template");
       process.exit(1);
@@ -398,14 +725,14 @@ Total: ${result.length}`);
         subject: options.subject
       };
       if (options.htmlFile) {
-        const fs2 = await import("fs");
-        request.html_content = fs2.readFileSync(options.htmlFile, "utf-8");
+        const fs3 = await import("fs");
+        request.html_content = fs3.readFileSync(options.htmlFile, "utf-8");
       } else if (options.html) {
         request.html_content = options.html;
       }
       if (options.textFile) {
-        const fs2 = await import("fs");
-        request.text_content = fs2.readFileSync(options.textFile, "utf-8");
+        const fs3 = await import("fs");
+        request.text_content = fs3.readFileSync(options.textFile, "utf-8");
       } else if (options.text) {
         request.text_content = options.text;
       }
@@ -413,16 +740,31 @@ Total: ${result.length}`);
       if (options.replyTo) request.reply_to = options.replyTo;
       if (options.previewText) request.preview_text = options.previewText;
       const template = await client.templates.create(request);
+      const previewUrl = await handleTemplatePreview({
+        id: template.id,
+        html_content: template.html_content ?? void 0
+      });
       if (options.format === "json") {
-        output(template, "json");
+        output({
+          ...template,
+          preview_url: previewUrl
+        }, "json");
       } else {
         success(`Template created: ${template.id}`);
-        output({
+        const tableData = {
           ID: template.id,
           Name: template.name,
           Subject: template.subject,
           Variables: template.variables?.join(", ") || "-"
-        }, "table");
+        };
+        if (previewUrl) {
+          tableData["Preview URL"] = previewUrl;
+        }
+        output(tableData, "table");
+        if (previewUrl) {
+          console.log(`
+Open the Preview URL in your browser to view the rendered template.`);
+        }
       }
     } catch (err) {
       error(err instanceof Error ? err.message : "Failed to create template");
@@ -440,14 +782,14 @@ Total: ${result.length}`);
       if (options.name) request.name = options.name;
       if (options.subject) request.subject = options.subject;
       if (options.htmlFile) {
-        const fs2 = await import("fs");
-        request.html_content = fs2.readFileSync(options.htmlFile, "utf-8");
+        const fs3 = await import("fs");
+        request.html_content = fs3.readFileSync(options.htmlFile, "utf-8");
       } else if (options.html) {
         request.html_content = options.html;
       }
       if (options.textFile) {
-        const fs2 = await import("fs");
-        request.text_content = fs2.readFileSync(options.textFile, "utf-8");
+        const fs3 = await import("fs");
+        request.text_content = fs3.readFileSync(options.textFile, "utf-8");
       } else if (options.text) {
         request.text_content = options.text;
       }
@@ -480,6 +822,51 @@ Total: ${result.length}`);
       process.exit(1);
     }
   });
+  cmd.command("preview <id>").description("Preview a template in the browser (keeps server running until Ctrl+C)").option("--no-open", "Do not automatically open browser").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr3({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      console.log(`Fetching template ${id}...`);
+      const template = await client.templates.get(id);
+      const htmlContent = template.html_content ?? "";
+      saveTemplate(template.id, htmlContent);
+      const previewUrl = await getPreviewUrl(template.id);
+      if (!previewUrl) {
+        error("Failed to start preview server");
+        process.exit(1);
+      }
+      keepServerAlive();
+      console.log(`
+Template: ${template.name}`);
+      console.log(`Preview URL: ${previewUrl}`);
+      if (options.open !== false) {
+        try {
+          const open = await import("open");
+          await open.default(previewUrl);
+          console.log("\nBrowser opened. Press Ctrl+C to stop the preview server.");
+        } catch {
+          console.log("\nCould not open browser automatically. Open the URL above manually.");
+          console.log("Press Ctrl+C to stop the preview server.");
+        }
+      } else {
+        console.log("\nOpen the URL above in your browser.");
+        console.log("Press Ctrl+C to stop the preview server.");
+      }
+      process.on("SIGINT", async () => {
+        console.log("\n\nStopping preview server...");
+        const server = getPreviewServer();
+        await server.stop();
+        console.log("Done.");
+        process.exit(0);
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to preview template");
+      process.exit(1);
+    }
+  });
   return cmd;
 }
@@ -1289,8 +1676,346 @@ function createSegmentsCommand() {
   return cmd;
 }
+// src/commands/login.ts
+import { Command as Command9 } from "commander";
+// src/server/callback.ts
+import http2 from "http";
+import { URL } from "url";
+function parseCallbackParams(url) {
+  try {
+    const fullUrl = url.startsWith("http") ? url : `http://localhost${url}`;
+    const parsed = new URL(fullUrl);
+    return {
+      key: parsed.searchParams.get("key") ?? void 0,
+      state: parsed.searchParams.get("state") ?? void 0,
+      error: parsed.searchParams.get("error") ?? void 0,
+      message: parsed.searchParams.get("message") ?? void 0
+    };
+  } catch {
+    return {};
+  }
+}
+function generateSuccessHtml() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Login Successful - Emailr CLI</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: #fff;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 16px;
+      backdrop-filter: blur(10px);
+      max-width: 400px;
+    }
+    .icon {
+      font-size: 4rem;
+      margin-bottom: 1rem;
+    }
+    h1 {
+      margin: 0 0 1rem 0;
+      font-size: 1.5rem;
+    }
+    p {
+      margin: 0;
+      opacity: 0.9;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="icon">\u2713</div>
+    <h1>Login Successful!</h1>
+    <p>You can close this window and return to your terminal.</p>
+  </div>
+</body>
+</html>`;
+}
+function generateErrorHtml(errorMessage) {
+  const escapedMessage = errorMessage.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Login Failed - Emailr CLI</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+      color: #fff;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 16px;
+      backdrop-filter: blur(10px);
+      max-width: 400px;
+    }
+    .icon {
+      font-size: 4rem;
+      margin-bottom: 1rem;
+    }
+    h1 {
+      margin: 0 0 1rem 0;
+      font-size: 1.5rem;
+    }
+    p {
+      margin: 0;
+      opacity: 0.9;
+    }
+    .error-message {
+      margin-top: 1rem;
+      padding: 1rem;
+      background: rgba(0, 0, 0, 0.2);
+      border-radius: 8px;
+      font-size: 0.9rem;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="icon">\u2717</div>
+    <h1>Login Failed</h1>
+    <p>Something went wrong during authentication.</p>
+    <div class="error-message">${escapedMessage}</div>
+    <p style="margin-top: 1rem;">Please close this window and try again.</p>
+  </div>
+</body>
+</html>`;
+}
+function createCallbackServer() {
+  let server = null;
+  let port = 0;
+  let callbackPromiseResolve = null;
+  let timeoutId = null;
+  let expectedState = null;
+  return {
+    async start() {
+      return new Promise((resolve, reject) => {
+        server = http2.createServer((req, res) => {
+          if (req.method !== "GET" || !req.url?.startsWith("/callback")) {
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.end("Not Found");
+            return;
+          }
+          const params = parseCallbackParams(req.url);
+          if (expectedState && params.state !== expectedState) {
+            res.writeHead(400, { "Content-Type": "text/html" });
+            res.end(generateErrorHtml("Security verification failed. State parameter mismatch."));
+            if (callbackPromiseResolve) {
+              callbackPromiseResolve({
+                success: false,
+                error: "State parameter mismatch"
+              });
+            }
+            return;
+          }
+          if (params.error) {
+            const errorMessage = params.message || params.error;
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(generateErrorHtml(errorMessage));
+            if (callbackPromiseResolve) {
+              callbackPromiseResolve({
+                success: false,
+                error: errorMessage
+              });
+            }
+            return;
+          }
+          if (params.key) {
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(generateSuccessHtml());
+            if (callbackPromiseResolve) {
+              callbackPromiseResolve({
+                success: true,
+                apiKey: params.key
+              });
+            }
+            return;
+          }
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(generateErrorHtml("Invalid callback: missing required parameters."));
+          if (callbackPromiseResolve) {
+            callbackPromiseResolve({
+              success: false,
+              error: "Invalid callback: missing required parameters"
+            });
+          }
+        });
+        server.listen(0, "127.0.0.1", () => {
+          const address = server.address();
+          if (address && typeof address === "object") {
+            port = address.port;
+            resolve({
+              port,
+              url: `http://127.0.0.1:${port}/callback`
+            });
+          } else {
+            reject(new Error("Failed to get server address"));
+          }
+        });
+        server.on("error", (err) => {
+          reject(new Error(`Failed to start callback server: ${err.message}`));
+        });
+      });
+    },
+    async waitForCallback(state, timeoutMs) {
+      expectedState = state;
+      return new Promise((resolve) => {
+        callbackPromiseResolve = resolve;
+        timeoutId = setTimeout(() => {
+          if (callbackPromiseResolve) {
+            callbackPromiseResolve({
+              success: false,
+              error: "Login timed out. Please try again."
+            });
+          }
+        }, timeoutMs);
+      });
+    },
+    async stop() {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (server) {
+        return new Promise((resolve) => {
+          server.close(() => {
+            server = null;
+            resolve();
+          });
+        });
+      }
+    }
+  };
+}
+// src/utils/state.ts
+import crypto from "crypto";
+function generateState() {
+  return crypto.randomBytes(32).toString("hex");
+}
+// src/utils/browser.ts
+import { exec } from "child_process";
+function openBrowser(url) {
+  return new Promise((resolve) => {
+    const platform = process.platform;
+    let command;
+    switch (platform) {
+      case "darwin":
+        command = `open "${url}"`;
+        break;
+      case "win32":
+        command = `start "" "${url}"`;
+        break;
+      default:
+        command = `xdg-open "${url}"`;
+        break;
+    }
+    exec(command, (error2) => {
+      if (error2) {
+        resolve(false);
+      } else {
+        resolve(true);
+      }
+    });
+  });
+}
+// src/commands/login.ts
+var DEFAULT_TIMEOUT_SECONDS = 120;
+var WEB_APP_BASE_URL = process.env.EMAILR_WEB_URL || "https://emailr.dev";
+function buildAuthorizationUrl(state, callbackPort) {
+  const callbackUrl = `http://127.0.0.1:${callbackPort}/callback`;
+  const params = new URLSearchParams({
+    state,
+    callback_url: callbackUrl
+  });
+  return `${WEB_APP_BASE_URL}/cli/authorize?${params.toString()}`;
+}
+function createLoginCommand() {
+  const cmd = new Command9("login").description("Log in to Emailr via browser authentication").option("-t, --timeout <seconds>", "Timeout in seconds", String(DEFAULT_TIMEOUT_SECONDS)).option("--no-browser", "Don't automatically open the browser").action(async (options) => {
+    await executeLogin({
+      timeout: parseInt(options.timeout, 10) || DEFAULT_TIMEOUT_SECONDS,
+      noBrowser: options.browser === false
+    });
+  });
+  return cmd;
+}
+async function executeLogin(options) {
+  const callbackServer = createCallbackServer();
+  const timeoutMs = (options.timeout || DEFAULT_TIMEOUT_SECONDS) * 1e3;
+  try {
+    info("Starting authentication server...");
+    const { port, url } = await callbackServer.start();
+    const state = generateState();
+    const authUrl = buildAuthorizationUrl(state, port);
+    console.log("");
+    info("Authorization URL:");
+    console.log(`  ${authUrl}`);
+    console.log("");
+    if (!options.noBrowser) {
+      const browserOpened = await openBrowser(authUrl);
+      if (browserOpened) {
+        info("Browser opened. Please complete authentication in your browser.");
+      } else {
+        warn("Could not open browser automatically.");
+        info("Please open the URL above in your browser to continue.");
+      }
+    } else {
+      info("Please open the URL above in your browser to continue.");
+    }
+    console.log("");
+    info(`Waiting for authentication (timeout: ${options.timeout || DEFAULT_TIMEOUT_SECONDS}s)...`);
+    const result = await callbackServer.waitForCallback(state, timeoutMs);
+    if (result.success && result.apiKey) {
+      saveConfig({ apiKey: result.apiKey });
+      console.log("");
+      success("Login successful!");
+      info(`API key saved to: ${getConfigPath()}`);
+      info("You can now use the Emailr CLI.");
+    } else {
+      console.log("");
+      error(result.error || "Authentication failed.");
+      info("Please try again or use manual configuration:");
+      console.log("  emailr config set api-key <your-api-key>");
+      process.exit(1);
+    }
+  } catch (err) {
+    console.log("");
+    error(err instanceof Error ? err.message : "An unexpected error occurred.");
+    info("Please try again or use manual configuration:");
+    console.log("  emailr config set api-key <your-api-key>");
+    process.exit(1);
+  } finally {
+    await callbackServer.stop();
+  }
+}
 // src/index.ts
-var program = new Command9();
+var program = new Command10();
 program.name("emailr").description("Emailr CLI - Send emails and manage your email infrastructure").version("1.0.0");
 program.addCommand(createSendCommand());
 program.addCommand(createContactsCommand());
@@ -1300,4 +2025,5 @@ program.addCommand(createBroadcastsCommand());
 program.addCommand(createWebhooksCommand());
 program.addCommand(createSegmentsCommand());
 program.addCommand(createConfigCommand());
+program.addCommand(createLoginCommand());
 program.parse();

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "emailr-cli",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Command-line interface for the Emailr email API",
   "type": "module",
   "bin": {
@@ -10,25 +10,21 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "build:standalone": "npm run build && node scripts/build-standalone.js",
-    "dev": "tsup src/index.ts --format esm --watch",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
-  },
   "dependencies": {
-    "emailr": "workspace:*",
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.3",
-    "commander": "^12.0.0"
+    "commander": "^12.0.0",
+    "emailr": "^1.1.0",
+    "open": "^11.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "esbuild": "^0.20.0",
+    "fast-check": "^3.15.0",
     "postject": "1.0.0-alpha.6",
     "tsup": "^8.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^1.6.0"
   },
   "keywords": [
     "emailr",
@@ -54,5 +50,13 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "build:standalone": "npm run build && node scripts/build-standalone.js",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}