@hasna/connectors 1.3.13 → 1.3.14

package/connectors/connect-gmail/dist/index.js

@@ -0,0 +1,2174 @@
+// @bun
+// src/types/index.ts
+class GmailApiError extends Error {
+  statusCode;
+  errors;
+  constructor(message, statusCode, errors) {
+    super(message);
+    this.name = "GmailApiError";
+    this.statusCode = statusCode;
+    this.errors = errors;
+  }
+}
+
+// src/utils/auth.ts
+import { createServer } from "http";
+
+// src/utils/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync, renameSync, cpSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_PROFILE = "default";
+var CURRENT_PROFILE_FILE = "current_profile";
+var PROFILES_DIR = "profiles";
+var profileOverride;
+function resolveBaseConfigDir() {
+  return join(homedir(), ".connectors", "connect-gmail");
+}
+var BASE_CONFIG_DIR = resolveBaseConfigDir();
+function ensureBaseConfigDir() {
+  if (!existsSync(BASE_CONFIG_DIR)) {
+    mkdirSync(BASE_CONFIG_DIR, { recursive: true });
+  }
+}
+function getProfilesDir() {
+  return join(BASE_CONFIG_DIR, PROFILES_DIR);
+}
+function getCurrentProfileFile() {
+  return join(BASE_CONFIG_DIR, CURRENT_PROFILE_FILE);
+}
+function migrateToProfileStructure() {
+  const profilesDir = getProfilesDir();
+  const defaultProfileDir = join(profilesDir, DEFAULT_PROFILE);
+  if (existsSync(profilesDir)) {
+    return;
+  }
+  const oldConfigFile = join(BASE_CONFIG_DIR, "config.json");
+  const oldTokensFile = join(BASE_CONFIG_DIR, "tokens.json");
+  const oldSettingsFile = join(BASE_CONFIG_DIR, "settings.json");
+  const oldContactsDir = join(BASE_CONFIG_DIR, "contacts");
+  const hasOldStructure = existsSync(oldConfigFile) || existsSync(oldTokensFile) || existsSync(oldSettingsFile) || existsSync(oldContactsDir);
+  if (!hasOldStructure) {
+    mkdirSync(profilesDir, { recursive: true });
+    return;
+  }
+  mkdirSync(defaultProfileDir, { recursive: true });
+  if (existsSync(oldConfigFile)) {
+    renameSync(oldConfigFile, join(defaultProfileDir, "config.json"));
+  }
+  if (existsSync(oldTokensFile)) {
+    renameSync(oldTokensFile, join(defaultProfileDir, "tokens.json"));
+  }
+  if (existsSync(oldSettingsFile)) {
+    renameSync(oldSettingsFile, join(defaultProfileDir, "settings.json"));
+  }
+  if (existsSync(oldContactsDir)) {
+    cpSync(oldContactsDir, join(defaultProfileDir, "contacts"), { recursive: true });
+    rmSync(oldContactsDir, { recursive: true });
+  }
+  writeFileSync(getCurrentProfileFile(), DEFAULT_PROFILE);
+}
+function getCurrentProfile() {
+  if (profileOverride) {
+    return profileOverride;
+  }
+  ensureBaseConfigDir();
+  migrateToProfileStructure();
+  const currentProfileFile = getCurrentProfileFile();
+  if (existsSync(currentProfileFile)) {
+    try {
+      const profile = readFileSync(currentProfileFile, "utf-8").trim();
+      if (profile && profileExists(profile)) {
+        return profile;
+      }
+    } catch {}
+  }
+  return DEFAULT_PROFILE;
+}
+function profileExists(profile) {
+  const profileDir = join(getProfilesDir(), profile);
+  return existsSync(profileDir);
+}
+function listProfiles() {
+  ensureBaseConfigDir();
+  migrateToProfileStructure();
+  const profilesDir = getProfilesDir();
+  if (!existsSync(profilesDir)) {
+    return [];
+  }
+  return readdirSync(profilesDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).sort();
+}
+function resolveConfigDir() {
+  ensureBaseConfigDir();
+  migrateToProfileStructure();
+  const profile = getCurrentProfile();
+  const profileDir = join(getProfilesDir(), profile);
+  if (!existsSync(profileDir)) {
+    mkdirSync(profileDir, { recursive: true });
+  }
+  return profileDir;
+}
+function getConfigDirInternal() {
+  return resolveConfigDir();
+}
+function getConfigDir() {
+  return getConfigDirInternal();
+}
+function ensureConfigDir() {
+  const configDir = getConfigDirInternal();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+}
+function getExportsDir() {
+  return join(getConfigDirInternal(), "exports");
+}
+function ensureExportsDir() {
+  const dir = getExportsDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function loadConfig() {
+  ensureConfigDir();
+  const configFile = join(getConfigDirInternal(), "config.json");
+  if (!existsSync(configFile)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(configFile, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const configFile = join(getConfigDirInternal(), "config.json");
+  writeFileSync(configFile, JSON.stringify(config, null, 2));
+}
+function loadBaseConfig() {
+  ensureBaseConfigDir();
+  const configFile = join(BASE_CONFIG_DIR, "credentials.json");
+  if (!existsSync(configFile)) {
+    const profiles = listProfiles();
+    for (const profile of profiles) {
+      const profileConfigFile = join(getProfilesDir(), profile, "config.json");
+      if (existsSync(profileConfigFile)) {
+        try {
+          const content = readFileSync(profileConfigFile, "utf-8");
+          const profileConfig = JSON.parse(content);
+          if (profileConfig.clientId && profileConfig.clientSecret) {
+            writeFileSync(configFile, JSON.stringify({
+              clientId: profileConfig.clientId,
+              clientSecret: profileConfig.clientSecret
+            }, null, 2));
+            return { clientId: profileConfig.clientId, clientSecret: profileConfig.clientSecret };
+          }
+        } catch {}
+      }
+    }
+    return {};
+  }
+  try {
+    const content = readFileSync(configFile, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function getClientId() {
+  return process.env.GMAIL_CLIENT_ID || loadBaseConfig().clientId;
+}
+function getClientSecret() {
+  return process.env.GMAIL_CLIENT_SECRET || loadBaseConfig().clientSecret;
+}
+function loadTokens() {
+  ensureConfigDir();
+  const tokensFile = join(getConfigDirInternal(), "tokens.json");
+  if (!existsSync(tokensFile)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(tokensFile, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveTokens(tokens) {
+  ensureConfigDir();
+  const tokensFile = join(getConfigDirInternal(), "tokens.json");
+  writeFileSync(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+function getUserEmail() {
+  return loadConfig().userEmail;
+}
+function getUserName() {
+  return loadConfig().userName;
+}
+function getFormattedSender() {
+  const email = getUserEmail();
+  const name = getUserName();
+  if (!email) {
+    throw new Error("User email not configured");
+  }
+  if (name) {
+    return `"${name}" <${email}>`;
+  }
+  return email;
+}
+function clearTokens() {
+  const tokensFile = join(getConfigDirInternal(), "tokens.json");
+  if (existsSync(tokensFile)) {
+    writeFileSync(tokensFile, "{}");
+  }
+}
+function clearConfig() {
+  saveConfig({});
+  clearTokens();
+}
+function isAuthenticated() {
+  const tokens = loadTokens();
+  return tokens !== null && tokens.accessToken !== undefined && tokens.refreshToken !== undefined;
+}
+
+// src/utils/auth.ts
+var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+var GMAIL_SCOPES = [
+  "https://www.googleapis.com/auth/gmail.readonly",
+  "https://www.googleapis.com/auth/gmail.send",
+  "https://www.googleapis.com/auth/gmail.compose",
+  "https://www.googleapis.com/auth/gmail.modify",
+  "https://www.googleapis.com/auth/gmail.labels",
+  "https://www.googleapis.com/auth/gmail.settings.basic",
+  "https://mail.google.com/"
+].join(" ");
+var REDIRECT_PORT = 8089;
+var REDIRECT_URI = `http://127.0.0.1:${REDIRECT_PORT}`;
+function getAuthUrl() {
+  const clientId = getClientId();
+  if (!clientId) {
+    throw new Error('Client ID not configured. Run "connect-gmail config set-credentials" first.');
+  }
+  const params = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: REDIRECT_URI,
+    response_type: "code",
+    scope: GMAIL_SCOPES,
+    access_type: "offline",
+    prompt: "consent"
+  });
+  return `${GOOGLE_AUTH_URL}?${params.toString()}`;
+}
+async function exchangeCodeForTokens(code) {
+  const clientId = getClientId();
+  const clientSecret = getClientSecret();
+  if (!clientId || !clientSecret) {
+    throw new Error("OAuth credentials not configured");
+  }
+  const response = await fetch(GOOGLE_TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      code,
+      client_id: clientId,
+      client_secret: clientSecret,
+      redirect_uri: REDIRECT_URI,
+      grant_type: "authorization_code"
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = `Token exchange failed: ${response.status} ${response.statusText}`;
+    try {
+      const error = JSON.parse(errorText);
+      errorMessage = `Token exchange failed: ${error.error_description || error.error || response.statusText}`;
+      console.error("Token exchange error details:", error);
+    } catch {
+      errorMessage = `Token exchange failed: ${errorText || response.statusText}`;
+    }
+    throw new Error(errorMessage);
+  }
+  const data = await response.json();
+  const tokens = {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1000,
+    tokenType: data.token_type,
+    scope: data.scope
+  };
+  return tokens;
+}
+async function refreshTokens(clientId, clientSecret, refreshToken, currentScope) {
+  const response = await fetch(GOOGLE_TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      client_id: clientId,
+      client_secret: clientSecret,
+      refresh_token: refreshToken,
+      grant_type: "refresh_token"
+    })
+  });
+  if (!response.ok) {
+    let errorMessage = `Token refresh failed: ${response.status} ${response.statusText}`;
+    try {
+      const errorBody = await response.json();
+      const detail = errorBody.error_description || errorBody.error;
+      if (detail) {
+        errorMessage = `Token refresh failed: ${detail}. Please run "connect-gmail auth login" again.`;
+      }
+    } catch {}
+    throw new Error(errorMessage);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken,
+    expiresAt: Date.now() + data.expires_in * 1000,
+    tokenType: data.token_type,
+    scope: data.scope || currentScope || ""
+  };
+}
+async function refreshAccessToken() {
+  const clientId = getClientId();
+  const clientSecret = getClientSecret();
+  const currentTokens = loadTokens();
+  if (!clientId || !clientSecret) {
+    throw new Error("OAuth credentials not configured");
+  }
+  if (!currentTokens?.refreshToken) {
+    throw new Error("No refresh token available. Please login again.");
+  }
+  const tokens = await refreshTokens(clientId, clientSecret, currentTokens.refreshToken, currentTokens.scope);
+  saveTokens(tokens);
+  return tokens;
+}
+function startCallbackServer() {
+  return new Promise((resolve) => {
+    const server = createServer(async (req, res) => {
+      const url = new URL(req.url || "", `http://127.0.0.1:${REDIRECT_PORT}`);
+      if (url.pathname === "/" || url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+                <div style="text-align: center;">
+                  <h1 style="color: #dc3545;">Authentication Failed</h1>
+                  <p>Error: ${error}</p>
+                  <p>You can close this window.</p>
+                </div>
+              </body>
+            </html>
+          `);
+          server.close();
+          resolve({ success: false, error });
+          return;
+        }
+        if (code) {
+          try {
+            const tokens = await exchangeCodeForTokens(code);
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(`
+              <html>
+                <body style="font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+                  <div style="text-align: center;">
+                    <h1 style="color: #28a745;">Authentication Successful!</h1>
+                    <p>You can close this window and return to the terminal.</p>
+                  </div>
+                </body>
+              </html>
+            `);
+            server.close();
+            resolve({ success: true, tokens });
+          } catch (err) {
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(`
+              <html>
+                <body style="font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+                  <div style="text-align: center;">
+                    <h1 style="color: #dc3545;">Authentication Failed</h1>
+                    <p>Error: ${String(err)}</p>
+                    <p>You can close this window.</p>
+                  </div>
+                </body>
+              </html>
+            `);
+            server.close();
+            resolve({ success: false, error: String(err) });
+          }
+        }
+      }
+    });
+    server.listen(REDIRECT_PORT, () => {});
+    setTimeout(() => {
+      server.close();
+      resolve({ success: false, error: "Authentication timed out" });
+    }, 5 * 60 * 1000);
+  });
+}
+async function getValidAccessToken() {
+  const tokens = loadTokens();
+  if (!tokens) {
+    throw new Error('Not authenticated. Run "connect-gmail auth login" first.');
+  }
+  if (Date.now() >= tokens.expiresAt - 5 * 60 * 1000) {
+    const newTokens = await refreshAccessToken();
+    return newTokens.accessToken;
+  }
+  return tokens.accessToken;
+}
+
+// src/api/client.ts
+var GMAIL_API_BASE = "https://gmail.googleapis.com/gmail/v1";
+
+class GmailClient {
+  accessToken;
+  userId = "me";
+  tokenProvider;
+  constructor(options) {
+    this.tokenProvider = options?.tokenProvider;
+  }
+  setUserId(userId) {
+    this.userId = userId;
+  }
+  getUserId() {
+    return this.userId;
+  }
+  buildUrl(path, params) {
+    const url = new URL(`${GMAIL_API_BASE}${path}`);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== "") {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    return url.toString();
+  }
+  async request(path, options = {}) {
+    const { method = "GET", params, body, headers = {} } = options;
+    const accessToken = this.tokenProvider ? await this.tokenProvider() : await getValidAccessToken();
+    const url = this.buildUrl(path, params);
+    const requestHeaders = {
+      Authorization: `Bearer ${accessToken}`,
+      Accept: "application/json",
+      ...headers
+    };
+    if (body && ["POST", "PUT", "PATCH"].includes(method)) {
+      if (typeof body === "string") {
+        requestHeaders["Content-Type"] = "message/rfc822";
+      } else {
+        requestHeaders["Content-Type"] = "application/json";
+      }
+    }
+    const fetchOptions = {
+      method,
+      headers: requestHeaders
+    };
+    if (body && ["POST", "PUT", "PATCH"].includes(method)) {
+      fetchOptions.body = typeof body === "string" ? body : JSON.stringify(body);
+    }
+    const response = await fetch(url, fetchOptions);
+    if (response.status === 204) {
+      return {};
+    }
+    let data;
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      const text = await response.text();
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          data = text;
+        }
+      }
+    } else {
+      data = await response.text();
+    }
+    if (!response.ok) {
+      const errorData = data;
+      const errorMessage = errorData?.error?.message || String(data || response.statusText);
+      throw new GmailApiError(errorMessage, response.status, errorData?.error?.errors);
+    }
+    return data;
+  }
+  async get(path, params) {
+    return this.request(path, { method: "GET", params });
+  }
+  async post(path, body, params) {
+    return this.request(path, { method: "POST", body, params });
+  }
+  async put(path, body, params) {
+    return this.request(path, { method: "PUT", body, params });
+  }
+  async patch(path, body, params) {
+    return this.request(path, { method: "PATCH", body, params });
+  }
+  async delete(path, params) {
+    return this.request(path, { method: "DELETE", params });
+  }
+}
+
+// src/utils/contacts.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, unlinkSync } from "fs";
+import { join as join2 } from "path";
+function getContactsDir() {
+  const dir = join2(getConfigDir(), "contacts");
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  return dir;
+}
+function emailToFilename(email) {
+  return email.toLowerCase().replace(/[^a-z0-9]/g, "_") + ".json";
+}
+function getContact(email) {
+  const contactsDir = getContactsDir();
+  const filename = emailToFilename(email);
+  const filepath = join2(contactsDir, filename);
+  if (!existsSync2(filepath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync2(filepath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function formatEmailWithName(email, fallbackName) {
+  const contact = getContact(email);
+  let displayName = fallbackName;
+  if (contact) {
+    if (contact.name) {
+      displayName = contact.name;
+    } else if (contact.firstName || contact.lastName) {
+      displayName = [contact.firstName, contact.lastName].filter(Boolean).join(" ");
+    }
+  }
+  if (displayName) {
+    return `"${displayName}" <${email}>`;
+  }
+  return email;
+}
+
+// src/utils/markdown.ts
+function markdownToHtml(markdown) {
+  let html = markdown;
+  html = html.replace(/&(?!amp;|lt;|gt;|quot;|#)/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  html = html.replace(/^### (.+)$/gm, "<h3>$1</h3>");
+  html = html.replace(/^## (.+)$/gm, "<h2>$1</h2>");
+  html = html.replace(/^# (.+)$/gm, "<h1>$1</h1>");
+  html = html.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, "<hr>");
+  html = html.replace(/\*\*\*(.+?)\*\*\*/g, "<strong><em>$1</em></strong>");
+  html = html.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+  html = html.replace(/\*(.+?)\*/g, "<em>$1</em>");
+  html = html.replace(/___(.+?)___/g, "<strong><em>$1</em></strong>");
+  html = html.replace(/__(.+?)__/g, "<strong>$1</strong>");
+  html = html.replace(/_(.+?)_/g, "<em>$1</em>");
+  html = html.replace(/~~(.+?)~~/g, "<del>$1</del>");
+  html = html.replace(/`([^`]+)`/g, '<code style="background:#f4f4f4;padding:2px 4px;border-radius:3px;">$1</code>');
+  html = html.replace(/```(\w*)\n([\s\S]*?)```/g, (_, lang, code) => {
+    return `<pre style="background:#f4f4f4;padding:12px;border-radius:4px;overflow-x:auto;"><code>${code.trim()}</code></pre>`;
+  });
+  html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" style="color:#1a73e8;">$1</a>');
+  html = html.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1" style="max-width:100%;">');
+  html = html.replace(/^> (.+)$/gm, '<blockquote style="border-left:4px solid #ddd;margin:0;padding-left:16px;color:#666;">$1</blockquote>');
+  html = html.replace(/^[\*\-] (.+)$/gm, '<li style="margin:0;padding:0;">$1</li>');
+  html = html.replace(/(<li style[^>]*>.*?<\/li>\n?)+/g, '<ul style="margin:4px 0;padding-left:20px;">$&</ul>');
+  html = html.replace(/^\d+\. (.+)$/gm, '<li style="margin:0;padding:0;">$1</li>');
+  html = html.replace(/\n\n+/g, "</p><p>");
+  html = `<p>${html}</p>`;
+  html = html.replace(/<\/li>\n<li/g, "</li><li");
+  html = html.replace(/<\/li>\n<\/ul>/g, "</li></ul>");
+  html = html.replace(/\n/g, "<br>");
+  html = html.replace(/<p><\/p>/g, "");
+  html = html.replace(/<p>(<h[1-6]>)/g, "$1");
+  html = html.replace(/(<\/h[1-6]>)<\/p>/g, "$1");
+  html = html.replace(/<p>(<ul)/g, "$1");
+  html = html.replace(/(<\/ul>)<\/p>/g, "$1");
+  html = html.replace(/<p>(<pre)/g, "$1");
+  html = html.replace(/(<\/pre>)<\/p>/g, "$1");
+  html = html.replace(/<p>(<blockquote)/g, "$1");
+  html = html.replace(/(<\/blockquote>)<\/p>/g, "$1");
+  html = html.replace(/<p><hr><\/p>/g, "<hr>");
+  return html;
+}
+function wrapInEmailTemplate(html) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <style>
+    ul, ol { margin: 4px 0; padding-left: 20px; }
+    li { margin: 0; padding: 0; line-height: 1.5; }
+    p { margin: 0 0 8px 0; }
+  </style>
+</head>
+<body style="font-family:Arial,sans-serif;font-size:14px;line-height:1.6;color:#202124;">
+${html}
+</body>
+</html>`;
+}
+function looksLikeMarkdown(text) {
+  const markdownPatterns = [
+    /^#{1,6} /m,
+    /\*\*.+\*\*/,
+    /\[.+\]\(.+\)/,
+    /^[\*\-] /m,
+    /^\d+\. /m,
+    /```/,
+    /^> /m
+  ];
+  return markdownPatterns.some((pattern) => pattern.test(text));
+}
+
+// src/utils/settings.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+var DEFAULT_SETTINGS = {
+  appendSignature: true,
+  appendSignatureToReplies: false,
+  markdownEnabled: true,
+  defaultFormat: "pretty",
+  defaultSendAsHtml: true
+};
+function getSettingsPath() {
+  return join3(getConfigDir(), "settings.json");
+}
+function loadSettings() {
+  ensureConfigDir();
+  const filepath = getSettingsPath();
+  if (!existsSync3(filepath)) {
+    saveSettings(DEFAULT_SETTINGS);
+    return DEFAULT_SETTINGS;
+  }
+  try {
+    const content = readFileSync3(filepath, "utf-8");
+    const loaded = JSON.parse(content);
+    return { ...DEFAULT_SETTINGS, ...loaded };
+  } catch {
+    return DEFAULT_SETTINGS;
+  }
+}
+function saveSettings(settings) {
+  ensureConfigDir();
+  const filepath = getSettingsPath();
+  writeFileSync3(filepath, JSON.stringify(settings, null, 2));
+}
+function getSignature() {
+  return loadSettings().signature;
+}
+function shouldAppendSignature(isReply = false) {
+  const settings = loadSettings();
+  if (isReply) {
+    return settings.appendSignatureToReplies;
+  }
+  return settings.appendSignature;
+}
+
+// src/api/messages.ts
+function encodeHeaderValue(value) {
+  if (!/[^\x00-\x7F]/.test(value)) {
+    return value;
+  }
+  const encoded = Buffer.from(value, "utf-8").toString("base64");
+  return `=?UTF-8?B?${encoded}?=`;
+}
+function htmlToPlainText(html) {
+  return html.replace(/<br\s*\/?>/gi, `
+`).replace(/<\/p>/gi, `
+
+`).replace(/<\/div>/gi, `
+`).replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/\n{3,}/g, `
+
+`).trim();
+}
+
+class MessagesApi {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    const params = {
+      maxResults: options.maxResults || 10,
+      pageToken: options.pageToken,
+      q: options.q,
+      includeSpamTrash: options.includeSpamTrash
+    };
+    if (options.labelIds && options.labelIds.length > 0) {
+      params.labelIds = options.labelIds.join(",");
+    }
+    return this.client.get(`/users/${this.client.getUserId()}/messages`, params);
+  }
+  async get(messageId, format = "full") {
+    return this.client.get(`/users/${this.client.getUserId()}/messages/${messageId}`, { format });
+  }
+  async send(options) {
+    const message = this.buildRawMessage(options);
+    const encodedMessage = Buffer.from(message).toString("base64url");
+    const body = {
+      raw: encodedMessage
+    };
+    if (options.threadId) {
+      body.threadId = options.threadId;
+    }
+    return this.client.post(`/users/${this.client.getUserId()}/messages/send`, body);
+  }
+  async reply(messageId, options) {
+    const original = await this.get(messageId, "full");
+    const headers = original.payload?.headers || [];
+    const getHeader = (name) => headers.find((h) => h.name.toLowerCase() === name.toLowerCase())?.value || "";
+    const originalFrom = getHeader("From");
+    const originalTo = getHeader("To");
+    const originalSubject = getHeader("Subject");
+    const originalMessageId = getHeader("Message-ID") || getHeader("Message-Id");
+    const originalReferences = getHeader("References");
+    const myEmail = getUserEmail();
+    let replyTo = originalFrom;
+    if (originalFrom.includes(myEmail || "")) {
+      replyTo = originalTo;
+    }
+    let references = originalReferences ? `${originalReferences} ${originalMessageId}` : originalMessageId;
+    let subject = originalSubject;
+    if (!subject.toLowerCase().startsWith("re:")) {
+      subject = `Re: ${subject}`;
+    }
+    const message = this.buildRawMessage({
+      to: replyTo,
+      cc: options.cc,
+      bcc: options.bcc,
+      subject,
+      body: options.body,
+      isHtml: options.isHtml,
+      threadId: original.threadId,
+      inReplyTo: originalMessageId,
+      references,
+      isReply: true
+    });
+    const encodedMessage = Buffer.from(message).toString("base64url");
+    return this.client.post(`/users/${this.client.getUserId()}/messages/send`, {
+      raw: encodedMessage,
+      threadId: original.threadId
+    });
+  }
+  async trash(messageId) {
+    return this.client.post(`/users/${this.client.getUserId()}/messages/${messageId}/trash`);
+  }
+  async untrash(messageId) {
+    return this.client.post(`/users/${this.client.getUserId()}/messages/${messageId}/untrash`);
+  }
+  async delete(messageId) {
+    await this.client.delete(`/users/${this.client.getUserId()}/messages/${messageId}`);
+  }
+  async modify(messageId, addLabelIds, removeLabelIds) {
+    return this.client.post(`/users/${this.client.getUserId()}/messages/${messageId}/modify`, {
+      addLabelIds: addLabelIds || [],
+      removeLabelIds: removeLabelIds || []
+    });
+  }
+  async addLabel(messageId, labelId) {
+    return this.modify(messageId, [labelId], undefined);
+  }
+  async removeLabel(messageId, labelId) {
+    return this.modify(messageId, undefined, [labelId]);
+  }
+  async addLabels(messageId, labelIds) {
+    return this.modify(messageId, labelIds, undefined);
+  }
+  async removeLabels(messageId, labelIds) {
+    return this.modify(messageId, undefined, labelIds);
+  }
+  async markAsRead(messageId) {
+    return this.modify(messageId, undefined, ["UNREAD"]);
+  }
+  async markAsUnread(messageId) {
+    return this.modify(messageId, ["UNREAD"]);
+  }
+  async star(messageId) {
+    return this.modify(messageId, ["STARRED"]);
+  }
+  async unstar(messageId) {
+    return this.modify(messageId, undefined, ["STARRED"]);
+  }
+  async archive(messageId) {
+    return this.modify(messageId, undefined, ["INBOX"]);
+  }
+  buildRawMessage(options) {
+    const settings = loadSettings();
+    const isReply = options.isReply || !!options.inReplyTo;
+    const formatAddresses = (addresses) => {
+      const addrs = Array.isArray(addresses) ? addresses : [addresses];
+      return addrs.map((addr) => {
+        if (addr.includes("<") && addr.includes(">")) {
+          return addr;
+        }
+        return formatEmailWithName(addr);
+      }).join(", ");
+    };
+    const to = formatAddresses(options.to);
+    const cc = options.cc ? formatAddresses(options.cc) : "";
+    const bcc = options.bcc ? formatAddresses(options.bcc) : "";
+    let body = options.body;
+    let isHtml = options.isHtml || false;
+    if (settings.markdownEnabled && !isHtml && looksLikeMarkdown(body)) {
+      body = markdownToHtml(body);
+      isHtml = true;
+    }
+    if (shouldAppendSignature(isReply)) {
+      const signature = getSignature();
+      if (signature) {
+        if (!isHtml) {
+          body = body.replace(/\n/g, "<br>");
+          isHtml = true;
+        }
+        body += `<br><br>${signature}`;
+      }
+    }
+    let from;
+    try {
+      from = getFormattedSender();
+    } catch {
+      from = getUserEmail() || "";
+    }
+    let message = "";
+    message += `From: ${from}\r
+`;
+    message += `To: ${to}\r
+`;
+    if (cc)
+      message += `Cc: ${cc}\r
+`;
+    if (bcc)
+      message += `Bcc: ${bcc}\r
+`;
+    message += `Subject: ${encodeHeaderValue(options.subject)}\r
+`;
+    if (options.inReplyTo) {
+      message += `In-Reply-To: ${options.inReplyTo}\r
+`;
+    }
+    if (options.references) {
+      message += `References: ${options.references}\r
+`;
+    }
+    message += `MIME-Version: 1.0\r
+`;
+    const mixedBoundary = `mixed_${Date.now()}`;
+    const altBoundary = `alt_${Date.now()}`;
+    if (options.attachments && options.attachments.length > 0) {
+      message += `Content-Type: multipart/mixed; boundary="${mixedBoundary}"\r
+\r
+`;
+      message += `--${mixedBoundary}\r
+`;
+      if (isHtml) {
+        const htmlBody = wrapInEmailTemplate(body);
+        const plainBody = htmlToPlainText(body);
+        message += `Content-Type: multipart/alternative; boundary="${altBoundary}"\r
+\r
+`;
+        message += `--${altBoundary}\r
+`;
+        message += `Content-Type: text/plain; charset="UTF-8"\r
+\r
+`;
+        message += `${plainBody}\r
+`;
+        message += `--${altBoundary}\r
+`;
+        message += `Content-Type: text/html; charset="UTF-8"\r
+\r
+`;
+        message += `${htmlBody}\r
+`;
+        message += `--${altBoundary}--\r
+`;
+      } else {
+        message += `Content-Type: text/plain; charset="UTF-8"\r
+\r
+`;
+        message += `${body}\r
+`;
+      }
+      for (const attachment of options.attachments) {
+        message += `--${mixedBoundary}\r
+`;
+        message += `Content-Type: ${attachment.mimeType}; name="${attachment.filename}"\r
+`;
+        message += `Content-Disposition: attachment; filename="${attachment.filename}"\r
+`;
+        message += `Content-Transfer-Encoding: base64\r
+\r
+`;
+        message += `${attachment.data}\r
+`;
+      }
+      message += `--${mixedBoundary}--`;
+    } else if (isHtml) {
+      const htmlBody = wrapInEmailTemplate(body);
+      const plainBody = htmlToPlainText(body);
+      message += `Content-Type: multipart/alternative; boundary="${altBoundary}"\r
+\r
+`;
+      message += `--${altBoundary}\r
+`;
+      message += `Content-Type: text/plain; charset="UTF-8"\r
+\r
+`;
+      message += `${plainBody}\r
+`;
+      message += `--${altBoundary}\r
+`;
+      message += `Content-Type: text/html; charset="UTF-8"\r
+\r
+`;
+      message += `${htmlBody}\r
+`;
+      message += `--${altBoundary}--`;
+    } else {
+      message += `Content-Type: text/plain; charset="UTF-8"\r
+\r
+`;
+      message += body;
+    }
+    return message;
+  }
+  extractBody(message, preferHtml = false) {
+    if (!message.payload)
+      return "";
+    const targetType = preferHtml ? "text/html" : "text/plain";
+    const getBaseMime = (mimeType) => {
+      if (!mimeType)
+        return "";
+      return mimeType.split(";")[0].trim().toLowerCase();
+    };
+    const collectTextParts = (part, results = []) => {
+      if (part.body?.data && part.mimeType) {
+        const baseMime = getBaseMime(part.mimeType);
+        if (baseMime.startsWith("text/")) {
+          results.push({
+            mimeType: baseMime,
+            data: Buffer.from(part.body.data, "base64url").toString("utf-8")
+          });
+        }
+      }
+      if (part.parts) {
+        for (const p of part.parts) {
+          collectTextParts(p, results);
+        }
+      }
+      return results;
+    };
+    const textParts = collectTextParts(message.payload);
+    const exactMatch = textParts.find((p) => p.mimeType === targetType);
+    if (exactMatch) {
+      return exactMatch.data;
+    }
+    const altMatch = textParts.find((p) => p.mimeType.startsWith("text/"));
+    return altMatch?.data || "";
+  }
+  extractInlineImages(message) {
+    if (!message.payload)
+      return [];
+    const images = [];
+    const collectImages = (part) => {
+      if (part.body?.data && part.mimeType?.startsWith("image/")) {
+        const contentIdHeader = part.headers?.find((h) => h.name.toLowerCase() === "content-id");
+        if (contentIdHeader) {
+          const contentId = contentIdHeader.value.replace(/^<|>$/g, "");
+          images.push({
+            contentId,
+            mimeType: part.mimeType,
+            data: part.body.data
+          });
+        }
+      }
+      if (part.parts) {
+        for (const p of part.parts) {
+          collectImages(p);
+        }
+      }
+    };
+    collectImages(message.payload);
+    return images;
+  }
+  getMessageStructure(message) {
+    if (!message.payload)
+      return {};
+    const buildStructure = (part, depth = 0) => {
+      const result = {
+        mimeType: part.mimeType,
+        size: part.body?.size || 0,
+        hasData: !!part.body?.data,
+        hasAttachmentId: !!part.body?.attachmentId
+      };
+      if (part.filename) {
+        result.filename = part.filename;
+      }
+      const contentIdHeader = part.headers?.find((h) => h.name.toLowerCase() === "content-id");
+      if (contentIdHeader) {
+        result.contentId = contentIdHeader.value;
+      }
+      if (part.parts && part.parts.length > 0) {
+        result.parts = part.parts.map((p) => buildStructure(p, depth + 1));
+      }
+      return result;
+    };
+    return buildStructure(message.payload);
+  }
+}
+
+// src/api/labels.ts
+class LabelsApi {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    return this.client.get(`/users/${this.client.getUserId()}/labels`);
+  }
+  async get(labelId) {
+    return this.client.get(`/users/${this.client.getUserId()}/labels/${labelId}`);
+  }
+  async create(options) {
+    const body = {
+      name: options.name
+    };
+    if (options.messageListVisibility) {
+      body.messageListVisibility = options.messageListVisibility;
+    }
+    if (options.labelListVisibility) {
+      body.labelListVisibility = options.labelListVisibility;
+    }
+    if (options.backgroundColor || options.textColor) {
+      body.color = {
+        backgroundColor: options.backgroundColor,
+        textColor: options.textColor
+      };
+    }
+    return this.client.post(`/users/${this.client.getUserId()}/labels`, body);
+  }
+  async update(labelId, options) {
+    const body = {
+      id: labelId
+    };
+    if (options.name) {
+      body.name = options.name;
+    }
+    if (options.messageListVisibility) {
+      body.messageListVisibility = options.messageListVisibility;
+    }
+    if (options.labelListVisibility) {
+      body.labelListVisibility = options.labelListVisibility;
+    }
+    if (options.backgroundColor || options.textColor) {
+      body.color = {
+        backgroundColor: options.backgroundColor,
+        textColor: options.textColor
+      };
+    }
+    return this.client.patch(`/users/${this.client.getUserId()}/labels/${labelId}`, body);
+  }
+  async delete(labelId) {
+    await this.client.delete(`/users/${this.client.getUserId()}/labels/${labelId}`);
+  }
+  async getByName(name) {
+    const { labels } = await this.list();
+    return labels.find((label) => label.name.toLowerCase() === name.toLowerCase());
+  }
+}
+
+// src/api/threads.ts
+class ThreadsApi {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    const params = {
+      maxResults: options.maxResults || 10,
+      pageToken: options.pageToken,
+      q: options.q,
+      includeSpamTrash: options.includeSpamTrash
+    };
+    if (options.labelIds && options.labelIds.length > 0) {
+      params.labelIds = options.labelIds.join(",");
+    }
+    return this.client.get(`/users/${this.client.getUserId()}/threads`, params);
+  }
+  async get(threadId, format = "full") {
+    return this.client.get(`/users/${this.client.getUserId()}/threads/${threadId}`, { format });
+  }
+  async trash(threadId) {
+    return this.client.post(`/users/${this.client.getUserId()}/threads/${threadId}/trash`);
+  }
+  async untrash(threadId) {
+    return this.client.post(`/users/${this.client.getUserId()}/threads/${threadId}/untrash`);
+  }
+  async delete(threadId) {
+    await this.client.delete(`/users/${this.client.getUserId()}/threads/${threadId}`);
+  }
+  async modify(threadId, addLabelIds, removeLabelIds) {
+    return this.client.post(`/users/${this.client.getUserId()}/threads/${threadId}/modify`, {
+      addLabelIds: addLabelIds || [],
+      removeLabelIds: removeLabelIds || []
+    });
+  }
+}
+
+// src/api/profile.ts
+class ProfileApi {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async get() {
+    return this.client.get(`/users/${this.client.getUserId()}/profile`);
+  }
+  async listSendAs() {
+    return this.client.get(`/users/${this.client.getUserId()}/settings/sendAs`);
+  }
+  async getSendAs(sendAsEmail) {
+    return this.client.get(`/users/${this.client.getUserId()}/settings/sendAs/${sendAsEmail}`);
+  }
+  async getPrimarySendAs() {
+    const { sendAs } = await this.listSendAs();
+    return sendAs.find((s) => s.isPrimary || s.isDefault);
+  }
+  async getSignature() {
+    const primary = await this.getPrimarySendAs();
+    return primary?.signature;
+  }
+  async getDisplayName() {
+    const primary = await this.getPrimarySendAs();
+    return primary?.displayName;
+  }
+}
+
+// src/api/drafts.ts
+function encodeHeaderValue2(value) {
+  if (!/[^\x00-\x7F]/.test(value)) {
+    return value;
+  }
+  const encoded = Buffer.from(value, "utf-8").toString("base64");
+  return `=?UTF-8?B?${encoded}?=`;
+}
+function htmlToPlainText2(html) {
+  return html.replace(/<br\s*\/?>/gi, `
+`).replace(/<\/p>/gi, `
+
+`).replace(/<\/div>/gi, `
+`).replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/\n{3,}/g, `
+
+`).trim();
+}
+
+class DraftsApi {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(maxResults = 10) {
+    return this.client.get(`/users/${this.client.getUserId()}/drafts`, { maxResults });
+  }
+  async get(draftId) {
+    return this.client.get(`/users/${this.client.getUserId()}/drafts/${draftId}`);
+  }
+  async create(options) {
+    const message = this.buildRawMessage(options);
+    const encodedMessage = Buffer.from(message).toString("base64url");
+    return this.client.post(`/users/${this.client.getUserId()}/drafts`, {
+      message: {
+        raw: encodedMessage
+      }
+    });
+  }
+  async update(draftId, options) {
+    const message = this.buildRawMessage(options);
+    const encodedMessage = Buffer.from(message).toString("base64url");
+    return this.client.put(`/users/${this.client.getUserId()}/drafts/${draftId}`, {
+      message: {
+        raw: encodedMessage
+      }
+    });
+  }
+  async delete(draftId) {
+    await this.client.delete(`/users/${this.client.getUserId()}/drafts/${draftId}`);
+  }
+  async send(draftId) {
+    return this.client.post(`/users/${this.client.getUserId()}/drafts/send`, { id: draftId });
+  }
+  buildRawMessage(options) {
+    const settings = loadSettings();
+    const formatAddresses = (addresses) => {
+      const addrs = Array.isArray(addresses) ? addresses : [addresses];
+      return addrs.map((addr) => {
+        if (addr.includes("<") && addr.includes(">")) {
+          return addr;
+        }
+        return formatEmailWithName(addr);
+      }).join(", ");
+    };
+    const to = formatAddresses(options.to);
+    const cc = options.cc ? formatAddresses(options.cc) : "";
+    const bcc = options.bcc ? formatAddresses(options.bcc) : "";
+    let body = options.body;
+    let isHtml = options.isHtml || false;
+    if (settings.markdownEnabled && !isHtml && looksLikeMarkdown(body)) {
+      body = markdownToHtml(body);
+      isHtml = true;
+    }
+    if (shouldAppendSignature(false)) {
+      const signature = getSignature();
+      if (signature) {
+        if (!isHtml) {
+          body = body.replace(/\n/g, "<br>");
+          isHtml = true;
+        }
+        body += `<br><br>${signature}`;
+      }
+    }
+    let from;
+    try {
+      from = getFormattedSender();
+    } catch {
+      from = getUserEmail() || "";
+    }
+    let message = "";
+    message += `From: ${from}\r
+`;
+    message += `To: ${to}\r
+`;
+    if (cc)
+      message += `Cc: ${cc}\r
+`;
+    if (bcc)
+      message += `Bcc: ${bcc}\r
+`;
+    message += `Subject: ${encodeHeaderValue2(options.subject)}\r
+`;
+    message += `MIME-Version: 1.0\r
+`;
+    if (isHtml) {
+      const boundary = `boundary_${Date.now()}`;
+      const htmlBody = wrapInEmailTemplate(body);
+      const plainBody = htmlToPlainText2(body);
+      message += `Content-Type: multipart/alternative; boundary="${boundary}"\r
+\r
+`;
+      message += `--${boundary}\r
+`;
+      message += `Content-Type: text/plain; charset="UTF-8"\r
+\r
+`;
+      message += `${plainBody}\r
+`;
+      message += `--${boundary}\r
+`;
+      message += `Content-Type: text/html; charset="UTF-8"\r
+\r
+`;
+      message += `${htmlBody}\r
+`;
+      message += `--${boundary}--`;
+    } else {
+      message += `Content-Type: text/plain; charset="UTF-8"\r
+\r
+`;
+      message += body;
+    }
+    return message;
+  }
+}
+
+// src/api/filters.ts
+class FiltersApi {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    return this.client.get(`/users/${this.client.getUserId()}/settings/filters`);
+  }
+  async get(filterId) {
+    return this.client.get(`/users/${this.client.getUserId()}/settings/filters/${filterId}`);
+  }
+  async create(options) {
+    return this.client.post(`/users/${this.client.getUserId()}/settings/filters`, {
+      criteria: options.criteria,
+      action: this.buildAction(options.action)
+    });
+  }
+  async delete(filterId) {
+    await this.client.delete(`/users/${this.client.getUserId()}/settings/filters/${filterId}`);
+  }
+  buildAction(action) {
+    const result = {};
+    if (action.addLabelIds) {
+      result.addLabelIds = action.addLabelIds;
+    }
+    if (action.removeLabelIds) {
+      result.removeLabelIds = action.removeLabelIds;
+    }
+    if (action.forward) {
+      result.forward = action.forward;
+    }
+    if (action.markImportant) {
+      result.addLabelIds = [...result.addLabelIds || [], "IMPORTANT"];
+    }
+    if (action.neverMarkImportant) {
+      result.removeLabelIds = [...result.removeLabelIds || [], "IMPORTANT"];
+    }
+    if (action.markRead) {
+      result.removeLabelIds = [...result.removeLabelIds || [], "UNREAD"];
+    }
+    if (action.archive) {
+      result.removeLabelIds = [...result.removeLabelIds || [], "INBOX"];
+    }
+    if (action.trash) {
+      result.addLabelIds = [...result.addLabelIds || [], "TRASH"];
+    }
+    if (action.star) {
+      result.addLabelIds = [...result.addLabelIds || [], "STARRED"];
+    }
+    if (action.neverSpam) {
+      result.removeLabelIds = [...result.removeLabelIds || [], "SPAM"];
+    }
+    return result;
+  }
+}
+
+// src/api/attachments.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
+class AttachmentsApi {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  getAttachmentsDir(messageId) {
+    const dir = join4(getConfigDir(), "attachments", messageId);
+    if (!existsSync4(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    return dir;
+  }
+  extractAttachments(part, attachments = []) {
+    if (part.body?.attachmentId && part.filename) {
+      attachments.push({
+        attachmentId: part.body.attachmentId,
+        filename: part.filename,
+        mimeType: part.mimeType,
+        size: part.body.size,
+        partId: part.partId
+      });
+    }
+    if (part.parts) {
+      for (const subpart of part.parts) {
+        this.extractAttachments(subpart, attachments);
+      }
+    }
+    return attachments;
+  }
+  async list(messageId) {
+    const message = await this.client.get(`/users/${this.client.getUserId()}/messages/${messageId}`, { format: "full" });
+    if (!message.payload) {
+      return [];
+    }
+    return this.extractAttachments(message.payload);
+  }
+  async get(messageId, attachmentId) {
+    return this.client.get(`/users/${this.client.getUserId()}/messages/${messageId}/attachments/${attachmentId}`);
+  }
+  async download(messageId, attachmentId, filename, mimeType, outputDir) {
+    const cleanFilename = filename.replace(/[\u00A0\u2000-\u200B\u202F\u205F\u3000]/g, " ");
+    const data = await this.get(messageId, attachmentId);
+    let dir;
+    if (outputDir) {
+      if (!existsSync4(outputDir)) {
+        mkdirSync3(outputDir, { recursive: true });
+      }
+      dir = outputDir;
+    } else {
+      dir = this.getAttachmentsDir(messageId);
+    }
+    const filepath = join4(dir, cleanFilename);
+    const buffer = Buffer.from(data.data, "base64url");
+    writeFileSync4(filepath, buffer);
+    return {
+      filename: cleanFilename,
+      path: filepath,
+      size: buffer.length,
+      mimeType
+    };
+  }
+  async downloadAll(messageId, outputDir) {
+    const attachments = await this.list(messageId);
+    const downloaded = [];
+    for (const attachment of attachments) {
+      const result = await this.download(messageId, attachment.attachmentId, attachment.filename, attachment.mimeType, outputDir);
+      downloaded.push(result);
+    }
+    return downloaded;
+  }
+  getStoragePath(messageId) {
+    return this.getAttachmentsDir(messageId);
+  }
+}
+
+// src/api/export.ts
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync5, appendFileSync } from "fs";
+import { join as join5, dirname } from "path";
+class ExportApi {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async exportMessages(options = {}) {
+    const format = options.format || "eml";
+    const messages = await this.getMessages(options);
+    if (messages.length === 0) {
+      const outputDir = options.outputDir || ensureExportsDir();
+      const filename = options.filename || `emails_${new Date().toISOString().split("T")[0]}.${format === "mbox" ? "mbox" : "eml"}`;
+      const filePath = join5(outputDir, filename);
+      writeFileSync5(filePath, "", "utf-8");
+      return {
+        messageCount: 0,
+        filePath,
+        format
+      };
+    }
+    if (format === "mbox") {
+      return this.exportToMbox(messages, options);
+    } else {
+      return this.exportToEml(messages, options);
+    }
+  }
+  async exportLabel(labelId, options = {}) {
+    return this.exportMessages({
+      ...options,
+      labelIds: [labelId]
+    });
+  }
+  async exportInbox(options = {}) {
+    return this.exportLabel("INBOX", options);
+  }
+  async exportSent(options = {}) {
+    return this.exportLabel("SENT", options);
+  }
+  async exportStarred(options = {}) {
+    return this.exportLabel("STARRED", options);
+  }
+  async exportMessage(messageId, options = {}) {
+    const message = await this.client.get(`/users/${this.client.getUserId()}/messages/${messageId}`, { format: "raw" });
+    const outputDir = options.outputDir || ensureExportsDir();
+    const filename = options.filename || `message_${messageId}.eml`;
+    const filePath = join5(outputDir, filename);
+    if (!existsSync5(dirname(filePath))) {
+      mkdirSync4(dirname(filePath), { recursive: true });
+    }
+    const rawContent = this.decodeBase64Url(message.raw || "");
+    writeFileSync5(filePath, rawContent, "utf-8");
+    return {
+      messageCount: 1,
+      filePath,
+      format: "eml"
+    };
+  }
+  async exportThread(threadId, options = {}) {
+    const thread = await this.client.get(`/users/${this.client.getUserId()}/threads/${threadId}`, { format: "minimal" });
+    const messageIds = thread.messages.map((m) => m.id);
+    const messages = [];
+    for (const id of messageIds) {
+      const message = await this.client.get(`/users/${this.client.getUserId()}/messages/${id}`, { format: "raw" });
+      messages.push(message);
+    }
+    const format = options.format || "mbox";
+    if (format === "mbox") {
+      return this.exportToMbox(messages, {
+        ...options,
+        filename: options.filename || `thread_${threadId}.mbox`
+      });
+    } else {
+      return this.exportToEml(messages, {
+        ...options,
+        filename: options.filename || `thread_${threadId}`
+      });
+    }
+  }
+  async exportToEml(messages, options) {
+    const outputDir = options.outputDir || ensureExportsDir();
+    const timestamp = new Date().toISOString().split("T")[0];
+    const exportDir = join5(outputDir, options.filename || `emails_${timestamp}`);
+    if (!existsSync5(exportDir)) {
+      mkdirSync4(exportDir, { recursive: true });
+    }
+    for (let i = 0;i < messages.length; i++) {
+      const message = messages[i];
+      const rawContent = this.decodeBase64Url(message.raw || "");
+      const subjectMatch = rawContent.match(/^Subject:\s*(.+)$/m);
+      let subject = subjectMatch ? subjectMatch[1].trim() : `message_${i + 1}`;
+      subject = this.sanitizeFilename(subject).slice(0, 50);
+      const filename = `${i + 1}_${message.id}_${subject}.eml`;
+      const filePath = join5(exportDir, filename);
+      writeFileSync5(filePath, rawContent, "utf-8");
+    }
+    return {
+      messageCount: messages.length,
+      filePath: exportDir,
+      format: "eml"
+    };
+  }
+  async exportToMbox(messages, options) {
+    const outputDir = options.outputDir || ensureExportsDir();
+    const filename = options.filename || `emails_${new Date().toISOString().split("T")[0]}.mbox`;
+    const filePath = join5(outputDir, filename);
+    if (!existsSync5(dirname(filePath))) {
+      mkdirSync4(dirname(filePath), { recursive: true });
+    }
+    writeFileSync5(filePath, "", "utf-8");
+    for (const message of messages) {
+      const rawContent = this.decodeBase64Url(message.raw || "");
+      const fromMatch = rawContent.match(/^From:\s*(.+)$/m);
+      let fromAddr = "unknown@unknown.com";
+      if (fromMatch) {
+        const emailMatch = fromMatch[1].match(/<([^>]+)>/) || fromMatch[1].match(/([^\s<>]+@[^\s<>]+)/);
+        if (emailMatch) {
+          fromAddr = emailMatch[1];
+        }
+      }
+      const dateMatch = rawContent.match(/^Date:\s*(.+)$/m);
+      let mboxDate = new Date().toUTCString();
+      if (dateMatch) {
+        try {
+          const parsed = new Date(dateMatch[1]);
+          if (!isNaN(parsed.getTime())) {
+            mboxDate = parsed.toUTCString().replace(/,/g, "").replace(/ GMT$/, "");
+          }
+        } catch {}
+      }
+      const mboxLine = `From ${fromAddr} ${mboxDate}
+`;
+      appendFileSync(filePath, mboxLine, "utf-8");
+      const escapedContent = rawContent.replace(/^From /gm, ">From ");
+      appendFileSync(filePath, escapedContent, "utf-8");
+      if (!rawContent.endsWith(`
+`)) {
+        appendFileSync(filePath, `
+`, "utf-8");
+      }
+      appendFileSync(filePath, `
+`, "utf-8");
+    }
+    return {
+      messageCount: messages.length,
+      filePath,
+      format: "mbox"
+    };
+  }
+  async getMessages(options) {
+    const messages = [];
+    let pageToken;
+    const maxResults = options.maxResults || 1000;
+    let fetched = 0;
+    do {
+      const params = {
+        maxResults: Math.min(100, maxResults - fetched),
+        pageToken,
+        q: options.query,
+        includeSpamTrash: false
+      };
+      if (options.labelIds && options.labelIds.length > 0) {
+        params.labelIds = options.labelIds.join(",");
+      }
+      const response = await this.client.get(`/users/${this.client.getUserId()}/messages`, params);
+      if (!response.messages || response.messages.length === 0) {
+        break;
+      }
+      for (const msg of response.messages) {
+        if (fetched >= maxResults)
+          break;
+        const fullMessage = await this.client.get(`/users/${this.client.getUserId()}/messages/${msg.id}`, { format: "raw" });
+        messages.push(fullMessage);
+        fetched++;
+      }
+      pageToken = response.nextPageToken;
+    } while (pageToken && fetched < maxResults);
+    return messages;
+  }
+  decodeBase64Url(encoded) {
+    let base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
+    while (base64.length % 4) {
+      base64 += "=";
+    }
+    return Buffer.from(base64, "base64").toString("utf-8");
+  }
+  sanitizeFilename(name) {
+    return name.replace(/[<>:"/\\|?*\x00-\x1F]/g, "").replace(/\s+/g, "_").replace(/^\.+/, "").slice(0, 200);
+  }
+}
+
+// src/api/bulk.ts
+function isLabelId(value) {
+  return value.startsWith("Label_") || /^[A-Z0-9_]+$/.test(value);
+}
+
+class BulkApi {
+  client;
+  messages;
+  labels;
+  constructor(client) {
+    this.client = client;
+    this.messages = new MessagesApi(client);
+    this.labels = new LabelsApi(client);
+  }
+  async preview(query, maxResults = 50) {
+    const messages = await this.fetchMessages(query, maxResults);
+    return {
+      messages,
+      total: messages.length,
+      query
+    };
+  }
+  async modifyLabels(options) {
+    const {
+      query,
+      maxResults = 100,
+      concurrency = 10,
+      dryRun = false,
+      addLabelIds = [],
+      removeLabelIds = [],
+      addLabels = [],
+      removeLabels = [],
+      skipIfLabeled = false,
+      offset = 0,
+      onProgress,
+      onError
+    } = options;
+    const resolvedAddIds = [...addLabelIds];
+    const resolvedRemoveIds = [...removeLabelIds];
+    if (addLabels.length > 0 || removeLabels.length > 0) {
+      const needsLookup = [...addLabels, ...removeLabels].some((v) => !isLabelId(v));
+      let labelMap = new Map;
+      if (needsLookup) {
+        const allLabels = await this.labels.list();
+        labelMap = new Map(allLabels.labels.map((l) => [l.name.toLowerCase(), l.id]));
+      }
+      for (const value of addLabels) {
+        if (isLabelId(value)) {
+          resolvedAddIds.push(value);
+        } else {
+          const id = labelMap.get(value.toLowerCase());
+          if (id)
+            resolvedAddIds.push(id);
+          else
+            throw new Error(`Label not found: ${value}`);
+        }
+      }
+      for (const value of removeLabels) {
+        if (isLabelId(value)) {
+          resolvedRemoveIds.push(value);
+        } else {
+          const id = labelMap.get(value.toLowerCase());
+          if (id)
+            resolvedRemoveIds.push(id);
+          else
+            throw new Error(`Label not found: ${value}`);
+        }
+      }
+    }
+    if (resolvedAddIds.length === 0 && resolvedRemoveIds.length === 0) {
+      throw new Error("At least one label to add or remove is required");
+    }
+    const fetchLimit = maxResults === Infinity ? Number.MAX_SAFE_INTEGER : maxResults + offset;
+    let messages = await this.fetchMessages(query, fetchLimit);
+    if (offset > 0) {
+      messages = messages.slice(offset);
+    }
+    if (maxResults !== Infinity && messages.length > maxResults) {
+      messages = messages.slice(0, maxResults);
+    }
+    if (skipIfLabeled && resolvedAddIds.length > 0) {
+      messages = messages.filter((msg) => {
+        const existing = msg.labelIds || [];
+        return !resolvedAddIds.every((id) => existing.includes(id));
+      });
+    }
+    return this.executeBatch(messages, {
+      dryRun,
+      concurrency,
+      onProgress,
+      onError,
+      operation: async (msg) => {
+        await this.messages.modify(msg.id, resolvedAddIds, resolvedRemoveIds);
+      }
+    });
+  }
+  async addLabels(options) {
+    return this.modifyLabels({
+      ...options,
+      removeLabelIds: [],
+      removeLabels: []
+    });
+  }
+  async removeLabels(options) {
+    return this.modifyLabels({
+      ...options,
+      addLabelIds: [],
+      addLabels: []
+    });
+  }
+  async archive(options) {
+    const messages = await this.fetchMessages(options.query, options.maxResults || 100);
+    return this.executeBatch(messages, {
+      dryRun: options.dryRun || false,
+      concurrency: options.concurrency || 10,
+      onProgress: options.onProgress,
+      onError: options.onError,
+      operation: async (msg) => {
+        await this.messages.archive(msg.id);
+      }
+    });
+  }
+  async unarchive(options) {
+    const messages = await this.fetchMessages(options.query, options.maxResults || 100);
+    return this.executeBatch(messages, {
+      dryRun: options.dryRun || false,
+      concurrency: options.concurrency || 10,
+      onProgress: options.onProgress,
+      onError: options.onError,
+      operation: async (msg) => {
+        await this.messages.modify(msg.id, ["INBOX"], undefined);
+      }
+    });
+  }
+  async trash(options) {
+    const messages = await this.fetchMessages(options.query, options.maxResults || 100);
+    return this.executeBatch(messages, {
+      dryRun: options.dryRun || false,
+      concurrency: options.concurrency || 10,
+      onProgress: options.onProgress,
+      onError: options.onError,
+      operation: async (msg) => {
+        await this.messages.trash(msg.id);
+      }
+    });
+  }
+  async delete(options) {
+    const messages = await this.fetchMessages(options.query, options.maxResults || 100);
+    return this.executeBatch(messages, {
+      dryRun: options.dryRun || false,
+      concurrency: options.concurrency || 10,
+      onProgress: options.onProgress,
+      onError: options.onError,
+      operation: async (msg) => {
+        await this.messages.delete(msg.id);
+      }
+    });
+  }
+  async untrash(options) {
+    const messages = await this.fetchMessages(options.query, options.maxResults || 100);
+    return this.executeBatch(messages, {
+      dryRun: options.dryRun || false,
+      concurrency: options.concurrency || 10,
+      onProgress: options.onProgress,
+      onError: options.onError,
+      operation: async (msg) => {
+        await this.messages.untrash(msg.id);
+      }
+    });
+  }
+  async markAsRead(options) {
+    const messages = await this.fetchMessages(options.query, options.maxResults || 100);
+    return this.executeBatch(messages, {
+      dryRun: options.dryRun || false,
+      concurrency: options.concurrency || 10,
+      onProgress: options.onProgress,
+      onError: options.onError,
+      operation: async (msg) => {
+        await this.messages.markAsRead(msg.id);
+      }
+    });
+  }
+  async markAsUnread(options) {
+    const messages = await this.fetchMessages(options.query, options.maxResults || 100);
+    return this.executeBatch(messages, {
+      dryRun: options.dryRun || false,
+      concurrency: options.concurrency || 10,
+      onProgress: options.onProgress,
+      onError: options.onError,
+      operation: async (msg) => {
+        await this.messages.markAsUnread(msg.id);
+      }
+    });
+  }
+  async star(options) {
+    const messages = await this.fetchMessages(options.query, options.maxResults || 100);
+    return this.executeBatch(messages, {
+      dryRun: options.dryRun || false,
+      concurrency: options.concurrency || 10,
+      onProgress: options.onProgress,
+      onError: options.onError,
+      operation: async (msg) => {
+        await this.messages.star(msg.id);
+      }
+    });
+  }
+  async unstar(options) {
+    const messages = await this.fetchMessages(options.query, options.maxResults || 100);
+    return this.executeBatch(messages, {
+      dryRun: options.dryRun || false,
+      concurrency: options.concurrency || 10,
+      onProgress: options.onProgress,
+      onError: options.onError,
+      operation: async (msg) => {
+        await this.messages.unstar(msg.id);
+      }
+    });
+  }
+  async batchModifyLabels(options) {
+    const {
+      query,
+      maxResults = 1000,
+      addLabelIds = [],
+      removeLabelIds = [],
+      addLabels = [],
+      removeLabels = [],
+      dryRun = false,
+      skipIfLabeled = false,
+      offset = 0
+    } = options;
+    const resolvedAddIds = [...addLabelIds];
+    const resolvedRemoveIds = [...removeLabelIds];
+    if (addLabels.length > 0 || removeLabels.length > 0) {
+      const needsLookup = [...addLabels, ...removeLabels].some((v) => !isLabelId(v));
+      let labelMap = new Map;
+      if (needsLookup) {
+        const allLabels = await this.labels.list();
+        labelMap = new Map(allLabels.labels.map((l) => [l.name.toLowerCase(), l.id]));
+      }
+      for (const value of addLabels) {
+        if (isLabelId(value)) {
+          resolvedAddIds.push(value);
+        } else {
+          const id = labelMap.get(value.toLowerCase());
+          if (id)
+            resolvedAddIds.push(id);
+          else
+            throw new Error(`Label not found: ${value}`);
+        }
+      }
+      for (const value of removeLabels) {
+        if (isLabelId(value)) {
+          resolvedRemoveIds.push(value);
+        } else {
+          const id = labelMap.get(value.toLowerCase());
+          if (id)
+            resolvedRemoveIds.push(id);
+          else
+            throw new Error(`Label not found: ${value}`);
+        }
+      }
+    }
+    let messageIds;
+    if (skipIfLabeled && resolvedAddIds.length > 0) {
+      const fetchLimit = maxResults === Infinity ? Number.MAX_SAFE_INTEGER : maxResults + offset;
+      let msgs = await this.fetchMessages(query, fetchLimit);
+      if (offset > 0)
+        msgs = msgs.slice(offset);
+      if (maxResults !== Infinity && msgs.length > maxResults)
+        msgs = msgs.slice(0, maxResults);
+      msgs = msgs.filter((msg) => {
+        const existing = msg.labelIds || [];
+        return !resolvedAddIds.every((id) => existing.includes(id));
+      });
+      messageIds = msgs.map((m) => m.id);
+    } else {
+      const fetchLimit = maxResults === Infinity ? Number.MAX_SAFE_INTEGER : maxResults + offset;
+      let ids = await this.fetchMessageIds(query, fetchLimit);
+      if (offset > 0)
+        ids = ids.slice(offset);
+      if (maxResults !== Infinity && ids.length > maxResults)
+        ids = ids.slice(0, maxResults);
+      messageIds = ids;
+    }
+    const messages = messageIds;
+    const result = {
+      total: messages.length,
+      success: 0,
+      failed: 0,
+      skipped: 0,
+      errors: [],
+      processedMessages: []
+    };
+    if (messages.length === 0) {
+      return result;
+    }
+    if (dryRun) {
+      result.success = messages.length;
+      result.processedMessages = messages.map((id) => ({ id, threadId: "" }));
+      return result;
+    }
+    const batchSize = 1000;
+    const batches = this.chunkArray(messages, batchSize);
+    for (const batch of batches) {
+      try {
+        await this.client.post(`/users/${this.client.getUserId()}/messages/batchModify`, {
+          ids: batch,
+          addLabelIds: resolvedAddIds.length > 0 ? resolvedAddIds : undefined,
+          removeLabelIds: resolvedRemoveIds.length > 0 ? resolvedRemoveIds : undefined
+        });
+        result.success += batch.length;
+        result.processedMessages.push(...batch.map((id) => ({ id, threadId: "" })));
+      } catch (err) {
+        result.failed += batch.length;
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        for (const id of batch) {
+          result.errors.push({ messageId: id, error: errorMessage });
+        }
+      }
+    }
+    return result;
+  }
+  async batchDelete(options) {
+    const { query, maxResults = 1000, dryRun = false } = options;
+    const messages = await this.fetchMessageIds(query, maxResults);
+    const result = {
+      total: messages.length,
+      success: 0,
+      failed: 0,
+      skipped: 0,
+      errors: [],
+      processedMessages: []
+    };
+    if (messages.length === 0) {
+      return result;
+    }
+    if (dryRun) {
+      result.success = messages.length;
+      result.processedMessages = messages.map((id) => ({ id, threadId: "" }));
+      return result;
+    }
+    const batchSize = 1000;
+    const batches = this.chunkArray(messages, batchSize);
+    for (const batch of batches) {
+      try {
+        await this.client.post(`/users/${this.client.getUserId()}/messages/batchDelete`, { ids: batch });
+        result.success += batch.length;
+        result.processedMessages.push(...batch.map((id) => ({ id, threadId: "" })));
+      } catch (err) {
+        result.failed += batch.length;
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        for (const id of batch) {
+          result.errors.push({ messageId: id, error: errorMessage });
+        }
+      }
+    }
+    return result;
+  }
+  async fetchMessages(query, maxResults) {
+    const messages = [];
+    let pageToken;
+    while (messages.length < maxResults) {
+      const response = await this.messages.list({
+        q: query,
+        maxResults: Math.min(100, maxResults - messages.length),
+        pageToken
+      });
+      if (!response.messages || response.messages.length === 0) {
+        break;
+      }
+      const metadataPromises = response.messages.map(async (m) => {
+        const msg = await this.messages.get(m.id, "metadata");
+        const headers = msg.payload?.headers || [];
+        const getHeader = (name) => headers.find((h) => h.name.toLowerCase() === name.toLowerCase())?.value;
+        return {
+          id: m.id,
+          threadId: m.threadId,
+          from: getHeader("from"),
+          subject: getHeader("subject"),
+          date: getHeader("date"),
+          snippet: msg.snippet,
+          labelIds: msg.labelIds
+        };
+      });
+      const fetchedMessages = await Promise.all(metadataPromises);
+      messages.push(...fetchedMessages);
+      pageToken = response.nextPageToken;
+      if (!pageToken)
+        break;
+    }
+    return messages;
+  }
+  async fetchMessageIds(query, maxResults) {
+    const messageIds = [];
+    let pageToken;
+    while (messageIds.length < maxResults) {
+      const response = await this.messages.list({
+        q: query,
+        maxResults: Math.min(500, maxResults - messageIds.length),
+        pageToken
+      });
+      if (!response.messages || response.messages.length === 0) {
+        break;
+      }
+      messageIds.push(...response.messages.map((m) => m.id));
+      pageToken = response.nextPageToken;
+      if (!pageToken)
+        break;
+    }
+    return messageIds;
+  }
+  async executeBatch(messages, options) {
+    const { dryRun, concurrency, onProgress, onError, operation } = options;
+    const result = {
+      total: messages.length,
+      success: 0,
+      failed: 0,
+      skipped: 0,
+      errors: [],
+      processedMessages: []
+    };
+    if (messages.length === 0) {
+      return result;
+    }
+    const chunks = this.chunkArray(messages, concurrency);
+    for (const chunk of chunks) {
+      await Promise.all(chunk.map(async (msg) => {
+        try {
+          if (dryRun) {
+            result.success++;
+            result.processedMessages.push(msg);
+          } else {
+            await operation(msg);
+            result.success++;
+            result.processedMessages.push(msg);
+          }
+          if (onProgress) {
+            onProgress(result.success + result.failed, result.total, msg);
+          }
+        } catch (err) {
+          result.failed++;
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          result.errors.push({ messageId: msg.id, error: errorMessage });
+          if (onError) {
+            onError(err instanceof Error ? err : new Error(errorMessage), msg);
+          }
+        }
+      }));
+    }
+    return result;
+  }
+  chunkArray(array, size) {
+    const chunks = [];
+    for (let i = 0;i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+}
+
+// src/api/index.ts
+class Gmail {
+  client;
+  messages;
+  labels;
+  threads;
+  profile;
+  drafts;
+  filters;
+  attachments;
+  export;
+  bulk;
+  constructor(client) {
+    this.client = client ?? new GmailClient;
+    this.messages = new MessagesApi(this.client);
+    this.labels = new LabelsApi(this.client);
+    this.threads = new ThreadsApi(this.client);
+    this.profile = new ProfileApi(this.client);
+    this.drafts = new DraftsApi(this.client);
+    this.filters = new FiltersApi(this.client);
+    this.attachments = new AttachmentsApi(this.client);
+    this.export = new ExportApi(this.client);
+    this.bulk = new BulkApi(this.client);
+  }
+  static create() {
+    return new Gmail;
+  }
+  static fromEnv() {
+    const accessToken = process.env.GMAIL_ACCESS_TOKEN;
+    const refreshToken = process.env.GMAIL_REFRESH_TOKEN;
+    const clientId = process.env.GMAIL_CLIENT_ID;
+    const clientSecret = process.env.GMAIL_CLIENT_SECRET;
+    const expiresAt = process.env.GMAIL_TOKEN_EXPIRES_AT ? parseInt(process.env.GMAIL_TOKEN_EXPIRES_AT, 10) : undefined;
+    if (refreshToken && clientId && clientSecret) {
+      return Gmail.createWithTokens({
+        accessToken: accessToken ?? "",
+        refreshToken,
+        clientId,
+        clientSecret,
+        expiresAt: accessToken ? expiresAt : 0
+      });
+    }
+    if (accessToken) {
+      const client = new GmailClient({ tokenProvider: async () => accessToken });
+      return new Gmail(client);
+    }
+    throw new Error("Missing Gmail env vars. Provide GMAIL_ACCESS_TOKEN, " + "or GMAIL_REFRESH_TOKEN + GMAIL_CLIENT_ID + GMAIL_CLIENT_SECRET");
+  }
+  static createWithTokens(tokens, onRefresh) {
+    let current = { ...tokens };
+    const tokenProvider = async () => {
+      const isExpired = current.expiresAt === undefined || Date.now() >= current.expiresAt - 5 * 60 * 1000;
+      if (isExpired) {
+        const refreshed = await refreshTokens(current.clientId, current.clientSecret, current.refreshToken);
+        current = {
+          accessToken: refreshed.accessToken,
+          refreshToken: refreshed.refreshToken,
+          clientId: current.clientId,
+          clientSecret: current.clientSecret,
+          expiresAt: refreshed.expiresAt
+        };
+        onRefresh?.(current);
+      }
+      return current.accessToken;
+    };
+    const client = new GmailClient({ tokenProvider });
+    return new Gmail(client);
+  }
+  getClient() {
+    return this.client;
+  }
+}
+export {
+  startCallbackServer,
+  saveTokens,
+  refreshTokens,
+  refreshAccessToken,
+  loadTokens,
+  isAuthenticated,
+  getValidAccessToken,
+  getAuthUrl,
+  clearConfig,
+  ThreadsApi,
+  ProfileApi,
+  MessagesApi,
+  LabelsApi,
+  GmailClient,
+  GmailApiError,
+  Gmail
+};