@hasna/connectors 1.3.22 → 1.3.24

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

@@ -1,2174 +0,0 @@
-// @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
-};