@hasna/connectors 1.3.25 → 1.3.26

package/bin/mcp.js

@@ -10573,7 +10573,7 @@ var CONNECTOR_NAME_RE, OPERATION_NAME_RE;
 var init_connector = __esm(() => {
   init_errors2();
   CONNECTOR_NAME_RE = /^[a-z0-9-]+$/;
-  OPERATION_NAME_RE = /^[a-z0-9:._-]+$/;
+  OPERATION_NAME_RE = /^[A-Za-z0-9:._-]+$/;
 });
 
 // src/core/registry.ts
@@ -11471,38 +11471,100 @@ Commands:
   });
 });
 
-// src/core/connectors/googledrive.ts
+// src/core/connectors/gmail.ts
 import { existsSync as existsSync2, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { basename, join as join2 } from "path";
-async function requestJson(profile, path, params) {
-  const response = await request(profile, path, params);
-  const text = await response.text();
-  return text ? JSON.parse(text) : {};
-}
-async function requestBinary(profile, path, params) {
-  return (await request(profile, path, params)).arrayBuffer();
+async function modifyMessage(profile, messageId, addLabelIds, removeLabelIds) {
+  return requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}/modify`, {}, {
+    method: "POST",
+    body: {
+      addLabelIds: addLabelIds ?? [],
+      removeLabelIds: removeLabelIds ?? []
+    }
+  });
+}
+async function replyToMessage(profile, messageId, input) {
+  const original = await requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}`, { format: "full" });
+  const headers = headersToObject(original.payload?.headers ?? []);
+  const subject = normalizeReplySubject(headers.Subject ?? headers.subject ?? "");
+  const to = headers.From ?? headers.from ?? "";
+  const messageIdHeader = headers["Message-ID"] ?? headers["Message-Id"] ?? headers["message-id"] ?? "";
+  const references = [headers.References ?? headers.references, messageIdHeader].filter(Boolean).join(" ");
+  const raw = buildRawEmail({
+    to,
+    cc: normalizeStringArray(input.cc),
+    bcc: normalizeStringArray(input.bcc),
+    subject,
+    body: input.body,
+    isHtml: Boolean(input.html ?? input.isHtml),
+    inReplyTo: messageIdHeader,
+    references
+  });
+  return requestJson(profile, "/users/me/messages/send", {}, {
+    method: "POST",
+    body: {
+      raw: Buffer.from(raw).toString("base64url"),
+      threadId: original.threadId
+    }
+  });
+}
+async function downloadAttachments(profile, input) {
+  const messageId = getMessageId(input);
+  const outputDir = input.dir ?? input.outputDir ?? join2(configDirs()[0], "attachments", messageId);
+  mkdirSync(outputDir, { recursive: true });
+  const attachments = input.attachmentId && input.filename ? [{
+    attachmentId: input.attachmentId,
+    filename: input.filename,
+    mimeType: input.mimeType ?? "application/octet-stream",
+    size: 0
+  }] : collectAttachments((await requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}`, { format: "full" })).payload);
+  const downloaded = [];
+  for (const attachment of attachments) {
+    const data = await requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachment.attachmentId)}`, {});
+    const filename = safeFilename(attachment.filename);
+    const path = join2(outputDir, filename);
+    const buffer = Buffer.from(data.data, "base64url");
+    writeFileSync(path, buffer);
+    downloaded.push({
+      filename,
+      path,
+      size: buffer.length,
+      mimeType: attachment.mimeType
+    });
+  }
+  return downloaded;
 }
-async function request(profile, path, params) {
+async function requestJson(profile, path, params, options = {}) {
   const token = await getValidAccessToken(profile);
-  const url = new URL(`${DRIVE_API_BASE}${path}`);
+  const url = new URL(`${GMAIL_API_BASE}${path}`);
   for (const [key, value] of Object.entries(params)) {
     if (value !== undefined && value !== null && value !== "")
-      url.searchParams.set(key, String(value));
+      url.searchParams.append(key, String(value));
   }
-  const response = await fetch(url, { headers: { Authorization: `Bearer ${token}`, Accept: "application/json" } });
+  const response = await fetch(url, {
+    method: options.method ?? "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json",
+      ...options.body ? { "Content-Type": "application/json" } : {}
+    },
+    body: options.body ? JSON.stringify(options.body) : undefined
+  });
+  const text = await response.text();
+  const data = text ? JSON.parse(text) : {};
   if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    throw new Error(`Google Drive request failed (${response.status}): ${extractGoogleError(body) || response.statusText}`);
+    const error2 = data;
+    throw new Error(`Gmail request failed (${response.status}): ${error2.error?.message ?? response.statusText}`);
   }
-  return response;
+  return data;
 }
 async function getValidAccessToken(profile) {
-  if (process.env.GOOGLE_ACCESS_TOKEN)
-    return process.env.GOOGLE_ACCESS_TOKEN;
+  if (process.env.GMAIL_ACCESS_TOKEN)
+    return process.env.GMAIL_ACCESS_TOKEN;
   const tokens = loadTokens(profile);
   if (!tokens?.accessToken && !tokens?.refreshToken) {
-    throw new Error(`Google Drive profile "${profile}" is not authenticated. Run: connectors auth googledrive`);
+    throw new Error(`Gmail profile "${profile}" is not authenticated. Run: connectors auth gmail`);
   }
   if (tokens.accessToken && (!tokens.expiresAt || Date.now() < tokens.expiresAt - REFRESH_BUFFER_MS))
     return tokens.accessToken;
@@ -11513,9 +11575,9 @@ async function getValidAccessToken(profile) {
 async function refreshAccessToken(profile, currentTokens) {
   const credentials = loadCredentials(profile);
   if (!credentials.clientId || !credentials.clientSecret)
-    throw new Error("Google Drive OAuth credentials are not configured. Run: connectors auth googledrive");
+    throw new Error("Gmail OAuth credentials are not configured. Run: connectors auth gmail");
   if (!currentTokens.refreshToken)
-    throw new Error(`Google Drive profile "${profile}" has no refresh token. Run: connectors auth googledrive`);
+    throw new Error(`Gmail profile "${profile}" has no refresh token. Run: connectors auth gmail`);
   const response = await fetch(TOKEN_URL, {
     method: "POST",
     headers: { "Content-Type": "application/x-www-form-urlencoded" },
@@ -11528,7 +11590,7 @@ async function refreshAccessToken(profile, currentTokens) {
   });
   const data = await response.json().catch(() => ({}));
   if (!response.ok || !data.access_token)
-    throw new Error(`Google Drive token refresh failed: ${data.error_description || data.error || response.statusText}`);
+    throw new Error(`Gmail token refresh failed: ${data.error_description || data.error || response.statusText}`);
   const tokens = {
     accessToken: data.access_token,
     refreshToken: currentTokens.refreshToken,
@@ -11555,8 +11617,8 @@ function listProfiles() {
   return Array.from(profiles).sort((a, b) => a.localeCompare(b));
 }
 function loadCredentials(profile) {
-  const envClientId = process.env.GOOGLE_CLIENT_ID;
-  const envClientSecret = process.env.GOOGLE_CLIENT_SECRET;
+  const envClientId = process.env.GMAIL_CLIENT_ID ?? process.env.GOOGLE_CLIENT_ID;
+  const envClientSecret = process.env.GMAIL_CLIENT_SECRET ?? process.env.GOOGLE_CLIENT_SECRET;
   if (envClientId && envClientSecret)
     return { clientId: envClientId, clientSecret: envClientSecret };
   for (const baseDir of configDirs()) {
@@ -11587,11 +11649,11 @@ function saveTokens(profile, tokens) {
   writeFileSync(join2(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 function configDirs() {
-  const explicit = process.env.HASNA_GOOGLE_DRIVE_CONNECTOR_DIR ?? process.env.GOOGLE_DRIVE_CONNECTOR_DIR;
+  const explicit = process.env.HASNA_GMAIL_CONNECTOR_DIR ?? process.env.GMAIL_CONNECTOR_DIR;
   if (explicit)
     return [explicit];
   const baseDir = process.env.HASNA_CONNECTORS_DIR ?? join2(homedir(), ".hasna", "connectors");
-  return [join2(baseDir, "connect-googledrive"), join2(baseDir, "googledrive")];
+  return [join2(baseDir, "connect-gmail"), join2(baseDir, "gmail")];
 }
 function readJson(path) {
   if (!existsSync2(path))
@@ -11602,6 +11664,378 @@ function readJson(path) {
     return null;
   }
 }
+function getMessageId(input) {
+  const id = input.messageId ?? (input.args?.[0] != null ? String(input.args[0]) : undefined);
+  if (!id)
+    throw new Error("Gmail messageId is required");
+  return id;
+}
+function headersToObject(headers) {
+  const out = {};
+  for (const header of headers)
+    out[header.name] = header.value;
+  return out;
+}
+function extractBody(message, preferHtml = false) {
+  if (!message.payload)
+    return "";
+  const targetType = preferHtml ? "text/html" : "text/plain";
+  const parts = [];
+  collectTextParts(message.payload, parts);
+  return parts.find((part) => part.mimeType === targetType)?.data ?? parts.find((part) => part.mimeType.startsWith("text/"))?.data ?? "";
+}
+function collectTextParts(part, results) {
+  const mimeType = (part.mimeType ?? "").split(";")[0].trim().toLowerCase();
+  if (part.body?.data && mimeType.startsWith("text/")) {
+    results.push({ mimeType, data: Buffer.from(part.body.data, "base64url").toString("utf8") });
+  }
+  for (const child of part.parts ?? [])
+    collectTextParts(child, results);
+}
+function collectAttachments(part, attachments = []) {
+  if (!part)
+    return attachments;
+  if (part.body?.attachmentId && part.filename) {
+    attachments.push({
+      attachmentId: part.body.attachmentId,
+      filename: part.filename,
+      mimeType: part.mimeType ?? "application/octet-stream",
+      size: part.body.size ?? 0,
+      partId: part.partId
+    });
+  }
+  for (const child of part.parts ?? [])
+    collectAttachments(child, attachments);
+  return attachments;
+}
+function normalizeStringArray(value) {
+  if (!value)
+    return [];
+  return Array.isArray(value) ? value : value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function normalizeReplySubject(subject) {
+  return subject.toLowerCase().startsWith("re:") ? subject : `Re: ${subject}`;
+}
+function buildRawEmail(input) {
+  const headers = [
+    `To: ${input.to}`,
+    input.cc.length ? `Cc: ${input.cc.join(", ")}` : "",
+    input.bcc.length ? `Bcc: ${input.bcc.join(", ")}` : "",
+    `Subject: ${input.subject}`,
+    input.inReplyTo ? `In-Reply-To: ${input.inReplyTo}` : "",
+    input.references ? `References: ${input.references}` : "",
+    "MIME-Version: 1.0",
+    `Content-Type: ${input.isHtml ? "text/html" : "text/plain"}; charset=UTF-8`
+  ].filter(Boolean);
+  return `${headers.join(`\r
+`)}\r
+\r
+${input.body}`;
+}
+function safeFilename(filename) {
+  return basename(filename.replace(/[\u00A0\u2000-\u200B\u202F\u205F\u3000]/g, " ")).replace(/[\/\\]/g, "_");
+}
+var GMAIL_API_BASE = "https://gmail.googleapis.com/gmail/v1", TOKEN_URL = "https://oauth2.googleapis.com/token", REFRESH_BUFFER_MS, listMessagesSchema, messageIdSchema, readMessageSchema, attachmentListSchema, attachmentDownloadSchema, historyListSchema, replySchema, gmailConnector;
+var init_gmail = __esm(() => {
+  init_zod();
+  init_connector();
+  REFRESH_BUFFER_MS = 5 * 60 * 1000;
+  listMessagesSchema = exports_external.object({
+    max: exports_external.coerce.number().int().positive().max(500).optional(),
+    maxResults: exports_external.coerce.number().int().positive().max(500).optional(),
+    pageToken: exports_external.string().optional(),
+    query: exports_external.string().optional(),
+    q: exports_external.string().optional(),
+    label: exports_external.string().optional(),
+    labelIds: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional(),
+    includeSpamTrash: exports_external.boolean().optional()
+  });
+  messageIdSchema = exports_external.object({
+    args: exports_external.array(exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean()])).optional(),
+    messageId: exports_external.string().optional()
+  });
+  readMessageSchema = messageIdSchema.extend({
+    body: exports_external.boolean().optional(),
+    html: exports_external.boolean().optional(),
+    format: exports_external.enum(["full", "metadata", "minimal", "raw"]).optional()
+  });
+  attachmentListSchema = messageIdSchema;
+  attachmentDownloadSchema = messageIdSchema.extend({
+    attachmentId: exports_external.string().optional(),
+    filename: exports_external.string().optional(),
+    mimeType: exports_external.string().optional(),
+    dir: exports_external.string().optional(),
+    outputDir: exports_external.string().optional()
+  });
+  historyListSchema = exports_external.object({
+    startHistoryId: exports_external.string(),
+    historyTypes: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional(),
+    labelId: exports_external.string().optional(),
+    maxResults: exports_external.coerce.number().int().positive().max(500).optional(),
+    pageToken: exports_external.string().optional()
+  });
+  replySchema = messageIdSchema.extend({
+    body: exports_external.string(),
+    html: exports_external.boolean().optional(),
+    isHtml: exports_external.boolean().optional(),
+    cc: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional(),
+    bcc: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).optional()
+  });
+  gmailConnector = defineConnector({
+    meta: {
+      name: "gmail",
+      displayName: "Gmail",
+      description: "Profile-aware Gmail mailbox operations for sync, labels, attachments, history, and replies.",
+      category: "communication",
+      tags: ["google", "gmail", "email", "mailbox"]
+    },
+    auth: {
+      type: "oauth2",
+      supportsProfiles: true,
+      fields: [
+        { key: "clientId", env: "GMAIL_CLIENT_ID", label: "OAuth client ID" },
+        { key: "clientSecret", env: "GMAIL_CLIENT_SECRET", label: "OAuth client secret", secret: true }
+      ]
+    },
+    createContext: ({ profile }) => ({ profile: profile || "default" }),
+    operations: {
+      "profiles.list": {
+        summary: "List configured Gmail profiles.",
+        execute: () => ({ profiles: listProfiles() })
+      },
+      "profile.get": {
+        summary: "Get the authenticated Gmail profile.",
+        execute: async ({ context }) => requestJson(context.profile, "/users/me/profile", {})
+      },
+      "messages.list": {
+        summary: "List Gmail messages.",
+        inputSchema: listMessagesSchema,
+        execute: async ({ context }, input) => {
+          const labelIds = normalizeStringArray(input.labelIds ?? input.label);
+          return requestJson(context.profile, "/users/me/messages", {
+            maxResults: input.maxResults ?? input.max ?? 50,
+            pageToken: input.pageToken,
+            q: input.q ?? input.query,
+            labelIds: labelIds.length > 0 ? labelIds.join(",") : undefined,
+            includeSpamTrash: input.includeSpamTrash
+          });
+        }
+      },
+      "messages.read": {
+        summary: "Read a Gmail message with optional extracted body.",
+        inputSchema: readMessageSchema,
+        execute: async ({ context }, input) => {
+          const messageId = getMessageId(input);
+          const message = await requestJson(context.profile, `/users/me/messages/${encodeURIComponent(messageId)}`, { format: input.format ?? "full" });
+          const headers = headersToObject(message.payload?.headers ?? []);
+          return {
+            ...message,
+            from: headers.From ?? headers.from ?? "",
+            to: headers.To ?? headers.to ?? "",
+            cc: headers.Cc ?? headers.cc ?? "",
+            subject: headers.Subject ?? headers.subject ?? "",
+            date: headers.Date ?? headers.date ?? "",
+            body: input.body ? extractBody(message, Boolean(input.html)) : undefined,
+            size: message.sizeEstimate
+          };
+        }
+      },
+      "messages.getRaw": {
+        summary: "Read raw base64url Gmail message content.",
+        inputSchema: messageIdSchema,
+        execute: async ({ context }, input) => {
+          const messageId = getMessageId(input);
+          return requestJson(context.profile, `/users/me/messages/${encodeURIComponent(messageId)}`, { format: "raw" });
+        }
+      },
+      "messages.mark-read": {
+        summary: "Mark a message as read.",
+        inputSchema: messageIdSchema,
+        execute: async ({ context }, input) => modifyMessage(context.profile, getMessageId(input), undefined, ["UNREAD"])
+      },
+      "messages.mark-unread": {
+        summary: "Mark a message as unread.",
+        inputSchema: messageIdSchema,
+        execute: async ({ context }, input) => modifyMessage(context.profile, getMessageId(input), ["UNREAD"], undefined)
+      },
+      "messages.archive": {
+        summary: "Archive a message by removing the INBOX label.",
+        inputSchema: messageIdSchema,
+        execute: async ({ context }, input) => modifyMessage(context.profile, getMessageId(input), undefined, ["INBOX"])
+      },
+      "messages.star": {
+        summary: "Star a message.",
+        inputSchema: messageIdSchema,
+        execute: async ({ context }, input) => modifyMessage(context.profile, getMessageId(input), ["STARRED"], undefined)
+      },
+      "messages.reply": {
+        summary: "Reply to a Gmail message in the same thread.",
+        inputSchema: replySchema,
+        execute: async ({ context }, input) => replyToMessage(context.profile, getMessageId(input), input)
+      },
+      "attachments.list": {
+        summary: "List Gmail message attachments.",
+        inputSchema: attachmentListSchema,
+        execute: async ({ context }, input) => {
+          const message = await requestJson(context.profile, `/users/me/messages/${encodeURIComponent(getMessageId(input))}`, { format: "full" });
+          return collectAttachments(message.payload);
+        }
+      },
+      "attachments.download": {
+        summary: "Download one or all Gmail message attachments to disk.",
+        inputSchema: attachmentDownloadSchema,
+        execute: async ({ context }, input) => downloadAttachments(context.profile, input)
+      },
+      "labels.list": {
+        summary: "List Gmail labels.",
+        execute: async ({ context }) => requestJson(context.profile, "/users/me/labels", {})
+      },
+      "history.list": {
+        summary: "List Gmail mailbox history from a history id.",
+        inputSchema: historyListSchema,
+        execute: async ({ context }, input) => requestJson(context.profile, "/users/me/history", {
+          startHistoryId: input.startHistoryId,
+          historyTypes: normalizeStringArray(input.historyTypes).join(",") || undefined,
+          labelId: input.labelId,
+          maxResults: input.maxResults,
+          pageToken: input.pageToken
+        })
+      }
+    }
+  });
+});
+
+// src/core/connectors/googledrive.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, join as join3 } from "path";
+async function requestJson2(profile, path, params) {
+  const response = await request(profile, path, params);
+  const text = await response.text();
+  return text ? JSON.parse(text) : {};
+}
+async function requestBinary(profile, path, params) {
+  return (await request(profile, path, params)).arrayBuffer();
+}
+async function request(profile, path, params) {
+  const token = await getValidAccessToken2(profile);
+  const url = new URL(`${DRIVE_API_BASE}${path}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null && value !== "")
+      url.searchParams.set(key, String(value));
+  }
+  const response = await fetch(url, { headers: { Authorization: `Bearer ${token}`, Accept: "application/json" } });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Google Drive request failed (${response.status}): ${extractGoogleError(body) || response.statusText}`);
+  }
+  return response;
+}
+async function getValidAccessToken2(profile) {
+  if (process.env.GOOGLE_ACCESS_TOKEN)
+    return process.env.GOOGLE_ACCESS_TOKEN;
+  const tokens = loadTokens2(profile);
+  if (!tokens?.accessToken && !tokens?.refreshToken) {
+    throw new Error(`Google Drive profile "${profile}" is not authenticated. Run: connectors auth googledrive`);
+  }
+  if (tokens.accessToken && (!tokens.expiresAt || Date.now() < tokens.expiresAt - REFRESH_BUFFER_MS2))
+    return tokens.accessToken;
+  if (!tokens.refreshToken)
+    return tokens.accessToken ?? "";
+  return (await refreshAccessToken2(profile, tokens)).accessToken ?? "";
+}
+async function refreshAccessToken2(profile, currentTokens) {
+  const credentials = loadCredentials2(profile);
+  if (!credentials.clientId || !credentials.clientSecret)
+    throw new Error("Google Drive OAuth credentials are not configured. Run: connectors auth googledrive");
+  if (!currentTokens.refreshToken)
+    throw new Error(`Google Drive profile "${profile}" has no refresh token. Run: connectors auth googledrive`);
+  const response = await fetch(TOKEN_URL2, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: credentials.clientId,
+      client_secret: credentials.clientSecret,
+      refresh_token: currentTokens.refreshToken,
+      grant_type: "refresh_token"
+    })
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok || !data.access_token)
+    throw new Error(`Google Drive token refresh failed: ${data.error_description || data.error || response.statusText}`);
+  const tokens = {
+    accessToken: data.access_token,
+    refreshToken: currentTokens.refreshToken,
+    expiresAt: Date.now() + (data.expires_in ?? 3600) * 1000,
+    tokenType: data.token_type ?? currentTokens.tokenType,
+    scope: data.scope ?? currentTokens.scope
+  };
+  saveTokens2(profile, tokens);
+  return tokens;
+}
+function listProfiles2() {
+  const profiles = new Set;
+  for (const baseDir of configDirs2()) {
+    const profilesDir = join3(baseDir, "profiles");
+    if (!existsSync3(profilesDir))
+      continue;
+    for (const entry of readdirSync2(profilesDir, { withFileTypes: true })) {
+      if (entry.isDirectory())
+        profiles.add(entry.name);
+      if (entry.isFile() && entry.name.endsWith(".json"))
+        profiles.add(basename2(entry.name, ".json"));
+    }
+  }
+  return Array.from(profiles).sort((a, b) => a.localeCompare(b));
+}
+function loadCredentials2(profile) {
+  const envClientId = process.env.GOOGLE_CLIENT_ID;
+  const envClientSecret = process.env.GOOGLE_CLIENT_SECRET;
+  if (envClientId && envClientSecret)
+    return { clientId: envClientId, clientSecret: envClientSecret };
+  for (const baseDir of configDirs2()) {
+    const credentials = {
+      ...readJson2(join3(baseDir, "credentials.json")),
+      ...readJson2(join3(baseDir, "profiles", profile, "config.json"))
+    };
+    if (credentials.clientId || credentials.clientSecret)
+      return credentials;
+  }
+  return {};
+}
+function loadTokens2(profile) {
+  for (const baseDir of configDirs2()) {
+    const fromProfile = readJson2(join3(baseDir, "profiles", profile, "tokens.json"));
+    if (fromProfile)
+      return fromProfile;
+    const flat = readJson2(join3(baseDir, "profiles", `${profile}.json`));
+    if (flat)
+      return flat.tokens ?? (flat.accessToken || flat.refreshToken ? flat : null);
+  }
+  return null;
+}
+function saveTokens2(profile, tokens) {
+  const baseDir = configDirs2().find((dir) => existsSync3(dir)) ?? configDirs2()[0];
+  const profileDir = join3(baseDir, "profiles", profile);
+  mkdirSync2(profileDir, { recursive: true });
+  writeFileSync2(join3(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+function configDirs2() {
+  const explicit = process.env.HASNA_GOOGLE_DRIVE_CONNECTOR_DIR ?? process.env.GOOGLE_DRIVE_CONNECTOR_DIR;
+  if (explicit)
+    return [explicit];
+  const baseDir = process.env.HASNA_CONNECTORS_DIR ?? join3(homedir2(), ".hasna", "connectors");
+  return [join3(baseDir, "connect-googledrive"), join3(baseDir, "googledrive")];
+}
+function readJson2(path) {
+  if (!existsSync3(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
 function defaultExportMimeType(googleMimeType) {
   if (googleMimeType.endsWith(".document"))
     return DEFAULT_EXPORT_FORMATS.document;
@@ -11626,11 +12060,11 @@ function extractGoogleError(body) {
     return body;
   }
 }
-var DRIVE_API_BASE = "https://www.googleapis.com/drive/v3", TOKEN_URL = "https://oauth2.googleapis.com/token", REFRESH_BUFFER_MS, DEFAULT_FILE_FIELDS, DEFAULT_EXPORT_FORMATS, EXPORT_EXTENSIONS, listFilesSchema, listDrivesSchema, fileIdSchema, downloadSchema, googleDriveConnector;
+var DRIVE_API_BASE = "https://www.googleapis.com/drive/v3", TOKEN_URL2 = "https://oauth2.googleapis.com/token", REFRESH_BUFFER_MS2, DEFAULT_FILE_FIELDS, DEFAULT_EXPORT_FORMATS, EXPORT_EXTENSIONS, listFilesSchema, listDrivesSchema, fileIdSchema, downloadSchema, googleDriveConnector;
 var init_googledrive = __esm(() => {
   init_zod();
   init_connector();
-  REFRESH_BUFFER_MS = 5 * 60 * 1000;
+  REFRESH_BUFFER_MS2 = 5 * 60 * 1000;
   DEFAULT_FILE_FIELDS = [
     "id",
     "name",
@@ -11711,12 +12145,12 @@ var init_googledrive = __esm(() => {
     operations: {
       "profiles.list": {
         summary: "List configured Google Drive profiles.",
-        execute: () => ({ profiles: listProfiles() })
+        execute: () => ({ profiles: listProfiles2() })
       },
       "files.list": {
         summary: "List Google Drive files.",
         inputSchema: listFilesSchema,
-        execute: async ({ context }, input) => requestJson(context.profile, "/files", {
+        execute: async ({ context }, input) => requestJson2(context.profile, "/files", {
           pageSize: input.pageSize ?? 1000,
           pageToken: input.pageToken,
           q: input.q,
@@ -11731,7 +12165,7 @@ var init_googledrive = __esm(() => {
       "files.get": {
         summary: "Get Google Drive file metadata.",
         inputSchema: fileIdSchema,
-        execute: async ({ context }, input) => requestJson(context.profile, `/files/${encodeURIComponent(input.fileId)}`, {
+        execute: async ({ context }, input) => requestJson2(context.profile, `/files/${encodeURIComponent(input.fileId)}`, {
           fields: input.fields ?? DEFAULT_FILE_FIELDS,
           supportsAllDrives: true
         })
@@ -11740,7 +12174,7 @@ var init_googledrive = __esm(() => {
         summary: "Download or export a Google Drive file as base64 content.",
         inputSchema: downloadSchema,
         execute: async ({ context }, input) => {
-          const file = input.file ?? await requestJson(context.profile, `/files/${encodeURIComponent(input.fileId)}`, { fields: DEFAULT_FILE_FIELDS, supportsAllDrives: true });
+          const file = input.file ?? await requestJson2(context.profile, `/files/${encodeURIComponent(input.fileId)}`, { fields: DEFAULT_FILE_FIELDS, supportsAllDrives: true });
           const exportMimeType = file.mimeType.startsWith("application/vnd.google-apps.") ? input.exportMimeType ?? defaultExportMimeType(file.mimeType) : undefined;
           const data = await requestBinary(context.profile, exportMimeType ? `/files/${encodeURIComponent(file.id)}/export` : `/files/${encodeURIComponent(file.id)}`, exportMimeType ? { mimeType: exportMimeType, supportsAllDrives: true } : { alt: "media", supportsAllDrives: true });
           const mimeType = exportMimeType ?? file.mimeType ?? "application/octet-stream";
@@ -11754,7 +12188,7 @@ var init_googledrive = __esm(() => {
       "drives.list": {
         summary: "List Google shared drives.",
         inputSchema: listDrivesSchema,
-        execute: async ({ context }, input) => requestJson(context.profile, "/drives", {
+        execute: async ({ context }, input) => requestJson2(context.profile, "/drives", {
           pageSize: input.pageSize ?? 100,
           pageToken: input.pageToken,
           q: input.q
@@ -11769,7 +12203,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/connectors",
-    version: "1.3.25",
+    version: "1.3.26",
     description: "Open source connector library - Install API connectors with a single command",
     type: "module",
     bin: {
@@ -11860,22 +12294,22 @@ var init_package = __esm(() => {
 import { createRequire } from "module";
 import { Database } from "bun:sqlite";
 import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
-  readdirSync as readdirSync2,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync3,
   copyFileSync
 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3, relative } from "path";
-import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, relative } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir22 } from "os";
 import { join as join22 } from "path";
 import { readdirSync as readdirSync22, existsSync as existsSync32 } from "fs";
 import { join as join32 } from "path";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir32 } from "os";
 import { hostname as hostname2 } from "os";
 import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
+import { join as join42 } from "path";
 import { join as join6, dirname as dirname2 } from "path";
 import { homedir as homedir5, platform } from "os";
 function __accessProp2(key) {
@@ -12748,13 +13182,13 @@ function custom3(check2, _params = {}, fatal) {
   return ZodAny2.create();
 }
 function getDataDir(serviceName) {
-  const dir = join3(HASNA_DIR, serviceName);
-  mkdirSync2(dir, { recursive: true });
+  const dir = join4(HASNA_DIR, serviceName);
+  mkdirSync3(dir, { recursive: true });
   return dir;
 }
 function getDbPath(serviceName) {
   const dir = getDataDir(serviceName);
-  return join3(dir, `${serviceName}.db`);
+  return join4(dir, `${serviceName}.db`);
 }
 function getConfigDir() {
   return CONFIG_DIR;
@@ -12767,7 +13201,7 @@ function getCloudConfig() {
     return CloudConfigSchema.parse({});
   }
   try {
-    const raw = readFileSync2(CONFIG_PATH, "utf-8");
+    const raw = readFileSync3(CONFIG_PATH, "utf-8");
     return CloudConfigSchema.parse(JSON.parse(raw));
   } catch {
     return CloudConfigSchema.parse({});
@@ -12775,7 +13209,7 @@ function getCloudConfig() {
 }
 function saveCloudConfig(config2) {
   mkdirSync22(CONFIG_DIR, { recursive: true });
-  writeFileSync2(CONFIG_PATH, JSON.stringify(config2, null, 2) + `
+  writeFileSync3(CONFIG_PATH, JSON.stringify(config2, null, 2) + `
 `, "utf-8");
 }
 function getConnectionString(dbName) {
@@ -12805,7 +13239,7 @@ function isSyncExcludedTable(table) {
   return SYNC_EXCLUDED_TABLE_PATTERNS.some((p) => p.test(table));
 }
 function discoverServices() {
-  const dataDir = join32(homedir3(), ".hasna");
+  const dataDir = join32(homedir32(), ".hasna");
   if (!existsSync32(dataDir))
     return [];
   try {
@@ -12827,7 +13261,7 @@ function discoverSyncableServices() {
   return local.filter((s) => pgSet.has(s));
 }
 function getServiceDbPath(service) {
-  const dataDir = join32(homedir3(), ".hasna", service);
+  const dataDir = join32(homedir32(), ".hasna", service);
   if (!existsSync32(dataDir))
     return null;
   const candidates = [
@@ -21771,7 +22205,7 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
     init_external2();
   });
   init_dotfile = __esm2(() => {
-    HASNA_DIR = join3(homedir2(), ".hasna");
+    HASNA_DIR = join4(homedir3(), ".hasna");
   });
   exports_config = {};
   __export2(exports_config, {
@@ -21867,7 +22301,7 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
   init_adapter();
   init_config();
   init_discover();
-  AUTO_SYNC_CONFIG_PATH = join4(homedir4(), ".hasna", "cloud", "config.json");
+  AUTO_SYNC_CONFIG_PATH = join42(homedir4(), ".hasna", "cloud", "config.json");
   init_config();
   init_adapter();
   init_dotfile();
@@ -21896,13 +22330,13 @@ __export(exports_database, {
 });
 import { dirname as dirname3, join as join5 } from "path";
 import { homedir as homedir6 } from "os";
-import { mkdirSync as mkdirSync3, existsSync as existsSync4, readdirSync as readdirSync3, copyFileSync as copyFileSync2, statSync } from "fs";
+import { mkdirSync as mkdirSync4, existsSync as existsSync5, readdirSync as readdirSync4, copyFileSync as copyFileSync2, statSync } from "fs";
 function mergeDirectoryContents(sourceDir, targetDir) {
-  if (!existsSync4(sourceDir)) {
+  if (!existsSync5(sourceDir)) {
     return;
   }
-  mkdirSync3(targetDir, { recursive: true });
-  for (const entry of readdirSync3(sourceDir)) {
+  mkdirSync4(targetDir, { recursive: true });
+  for (const entry of readdirSync4(sourceDir)) {
     const sourcePath = join5(sourceDir, entry);
     const targetPath = join5(targetDir, entry);
     try {
@@ -21911,7 +22345,7 @@ function mergeDirectoryContents(sourceDir, targetDir) {
         mergeDirectoryContents(sourcePath, targetPath);
         continue;
       }
-      if (!existsSync4(targetPath)) {
+      if (!existsSync5(targetPath)) {
         copyFileSync2(sourcePath, targetPath);
       }
     } catch {}
@@ -21921,7 +22355,7 @@ function getConnectorsHome() {
   const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir6();
   const newDir = join5(home, ".hasna", "connectors");
   const legacyDirs = [join5(home, ".connectors"), join5(home, ".connect")];
-  mkdirSync3(newDir, { recursive: true });
+  mkdirSync4(newDir, { recursive: true });
   for (const legacyDir of legacyDirs) {
     try {
       mergeDirectoryContents(legacyDir, newDir);
@@ -21939,7 +22373,7 @@ function getDatabase(path) {
     _dbPath = null;
   }
   if (dbPath !== ":memory:") {
-    mkdirSync3(dirname3(dbPath), { recursive: true });
+    mkdirSync4(dirname3(dbPath), { recursive: true });
   }
   _db = new SqliteAdapter(dbPath);
   _dbPath = dbPath;
@@ -22073,13 +22507,13 @@ var init_database = __esm(() => {
 
 // src/core/connectors/imessage.ts
 import {
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync3,
-  readdirSync as readdirSync4,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync5,
   rmSync,
   statSync as statSync2,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
 import { join as join7 } from "path";
 function buildRootHelp(specs) {
@@ -22133,19 +22567,19 @@ function getProfilesDir() {
 }
 function getCurrentProfile() {
   const currentProfileFile = join7(getConfigDir2(), "current_profile");
-  if (!existsSync5(currentProfileFile)) {
+  if (!existsSync6(currentProfileFile)) {
     return "default";
   }
   try {
-    return readFileSync3(currentProfileFile, "utf-8").trim() || "default";
+    return readFileSync4(currentProfileFile, "utf-8").trim() || "default";
   } catch {
     return "default";
   }
 }
 function setCurrentProfile(profile) {
   const configDir = getConfigDir2();
-  mkdirSync4(configDir, { recursive: true });
-  writeFileSync3(join7(configDir, "current_profile"), profile);
+  mkdirSync5(configDir, { recursive: true });
+  writeFileSync4(join7(configDir, "current_profile"), profile);
 }
 function getFlatProfilePath(profile) {
   return join7(getProfilesDir(), `${profile}.json`);
@@ -22155,7 +22589,7 @@ function getDirectoryProfilePath(profile) {
 }
 function loadJsonFile(path) {
   try {
-    return JSON.parse(readFileSync3(path, "utf-8"));
+    return JSON.parse(readFileSync4(path, "utf-8"));
   } catch {
     return {};
   }
@@ -22171,8 +22605,8 @@ function sanitizeProfileConfig(config2) {
   };
 }
 function loadProfile(profile = getCurrentProfile()) {
-  const flatConfig = existsSync5(getFlatProfilePath(profile)) ? loadJsonFile(getFlatProfilePath(profile)) : {};
-  const directoryConfig = existsSync5(getDirectoryProfilePath(profile)) ? loadJsonFile(getDirectoryProfilePath(profile)) : {};
+  const flatConfig = existsSync6(getFlatProfilePath(profile)) ? loadJsonFile(getFlatProfilePath(profile)) : {};
+  const directoryConfig = existsSync6(getDirectoryProfilePath(profile)) ? loadJsonFile(getDirectoryProfilePath(profile)) : {};
   return sanitizeProfileConfig({
     ...flatConfig,
     ...directoryConfig
@@ -22180,24 +22614,24 @@ function loadProfile(profile = getCurrentProfile()) {
 }
 function writeProfile(profile, config2) {
   const profilesDir = getProfilesDir();
-  mkdirSync4(profilesDir, { recursive: true });
-  writeFileSync3(getFlatProfilePath(profile), JSON.stringify(config2, null, 2) + `
+  mkdirSync5(profilesDir, { recursive: true });
+  writeFileSync4(getFlatProfilePath(profile), JSON.stringify(config2, null, 2) + `
 `);
 }
 function profileExists(profile) {
   if (profile === "default") {
     return true;
   }
-  return existsSync5(getFlatProfilePath(profile)) || existsSync5(join7(getProfilesDir(), profile));
+  return existsSync6(getFlatProfilePath(profile)) || existsSync6(join7(getProfilesDir(), profile));
 }
-function listProfiles2() {
+function listProfiles3() {
   const profilesDir = getProfilesDir();
   const seen = new Set(["default"]);
-  if (!existsSync5(profilesDir)) {
+  if (!existsSync6(profilesDir)) {
     return [...seen];
   }
   try {
-    for (const entry of readdirSync4(profilesDir)) {
+    for (const entry of readdirSync5(profilesDir)) {
       const fullPath = join7(profilesDir, entry);
       const stat = statSync2(fullPath);
       if (stat.isDirectory()) {
@@ -22220,10 +22654,10 @@ function createProfile(profile, config2 = {}) {
 function clearProfile(profile = getCurrentProfile()) {
   const flatPath = getFlatProfilePath(profile);
   const directoryPath = join7(getProfilesDir(), profile);
-  if (existsSync5(flatPath)) {
+  if (existsSync6(flatPath)) {
     rmSync(flatPath);
   }
-  if (existsSync5(directoryPath)) {
+  if (existsSync6(directoryPath)) {
     rmSync(directoryPath, { recursive: true, force: true });
   }
 }
@@ -22519,7 +22953,7 @@ async function sendMessage(context, input) {
     direction: "outbound"
   });
 }
-async function replyToMessage(context, input) {
+async function replyToMessage2(context, input) {
   const payload = await bridgeRequest(context, "/messages/reply", {
     method: "POST",
     body: {
@@ -22633,7 +23067,7 @@ async function runProfileCommand2(args, context) {
   switch (subcommand) {
     case "list": {
       const current = getCurrentProfile();
-      const profiles = listProfiles2();
+      const profiles = listProfiles3();
       return successOutput({ current, profiles }, context.format, () => profiles.map((profile) => `${profile}${profile === current ? " (active)" : ""}`).join(`
 `));
     }
@@ -22807,7 +23241,7 @@ async function runMessageCommand(args, context) {
       if (!conversationId || !text) {
         return failure2("Usage: connect-imessage message reply --conversation <id> --text <text>");
       }
-      return successOutput(await replyToMessage(resolved, {
+      return successOutput(await replyToMessage2(resolved, {
         conversationId,
         text,
         replyToMessageId: asString2(options.replyTo),
@@ -23085,7 +23519,7 @@ var init_imessage = __esm(() => {
         summary: "Reply to an existing conversation through the bridge",
         inputSchema: messageReplyInputSchema,
         async execute({ context }, input) {
-          return replyToMessage(context, input);
+          return replyToMessage2(context, input);
         }
       }
     },
@@ -23149,18 +23583,18 @@ var init_imessage = __esm(() => {
 });
 
 // src/core/connectors/stripe.ts
-import { existsSync as existsSync6 } from "fs";
-import { dirname as dirname4, join as join8 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { dirname as dirname4, join as join9 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
 function resolveStripeConnectorDir() {
   const candidates = [
-    join8(__dirname3, "..", "..", "..", "connectors", "connect-stripe"),
-    join8(__dirname3, "..", "..", "connectors", "connect-stripe"),
-    join8(__dirname3, "..", "connectors", "connect-stripe"),
-    join8(process.cwd(), "connectors", "connect-stripe")
+    join9(__dirname3, "..", "..", "..", "connectors", "connect-stripe"),
+    join9(__dirname3, "..", "..", "connectors", "connect-stripe"),
+    join9(__dirname3, "..", "connectors", "connect-stripe"),
+    join9(process.cwd(), "connectors", "connect-stripe")
   ];
   for (const candidate of candidates) {
-    if (existsSync6(candidate)) {
+    if (existsSync7(candidate)) {
       return candidate;
     }
   }
@@ -23208,10 +23642,10 @@ function buildCommandHelp2(spec) {
 `);
 }
 async function loadStripeApiModule() {
-  return await import(pathToFileURL2(join8(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
+  return await import(pathToFileURL2(join9(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
 }
 async function loadStripeConfigModule() {
-  return await import(pathToFileURL2(join8(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
+  return await import(pathToFileURL2(join9(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
 }
 function extractGlobalArgs3(args) {
   const remaining = [];
@@ -24032,10 +24466,12 @@ var INTERNAL_CONNECTOR_DEFINITIONS, INTERNAL_CONNECTOR_REGISTRY;
 var init_builtins = __esm(() => {
   init_registry();
   init_github();
+  init_gmail();
   init_googledrive();
   init_imessage();
   init_stripe();
   INTERNAL_CONNECTOR_DEFINITIONS = [
+    gmailConnector,
     githubConnector,
     googleDriveConnector,
     imessageConnector,
@@ -24055,25 +24491,25 @@ __export(exports_llm, {
   PROVIDER_DEFAULTS: () => PROVIDER_DEFAULTS,
   LLMClient: () => LLMClient
 });
-import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6 } from "fs";
+import { join as join11 } from "path";
 function getLlmConfigPath() {
-  return join10(getConnectorsHome(), "llm.json");
+  return join11(getConnectorsHome(), "llm.json");
 }
 function getLlmConfig() {
   const path = getLlmConfigPath();
-  if (!existsSync8(path))
+  if (!existsSync9(path))
     return null;
   try {
-    return JSON.parse(readFileSync5(path, "utf-8"));
+    return JSON.parse(readFileSync6(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveLlmConfig(config2) {
   const dir = getConnectorsHome();
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync4(getLlmConfigPath(), JSON.stringify(config2, null, 2));
+  mkdirSync6(dir, { recursive: true });
+  writeFileSync5(getLlmConfigPath(), JSON.stringify(config2, null, 2));
 }
 function setLlmStrip(enabled) {
   const config2 = getLlmConfig();
@@ -24192,15 +24628,15 @@ __export(exports_installer, {
   getConnectorDocs: () => getConnectorDocs,
   connectorExists: () => connectorExists
 });
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, readdirSync as readdirSync5, statSync as statSync3, rmSync as rmSync2 } from "fs";
-import { join as join11, dirname as dirname6 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync6, readdirSync as readdirSync6, statSync as statSync3, rmSync as rmSync2 } from "fs";
+import { join as join12, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function resolveConnectorsDir() {
-  const fromBin = join11(__dirname4, "..", "connectors");
-  if (existsSync9(fromBin))
+  const fromBin = join12(__dirname4, "..", "connectors");
+  if (existsSync10(fromBin))
     return fromBin;
-  const fromSrc = join11(__dirname4, "..", "..", "connectors");
-  if (existsSync9(fromSrc))
+  const fromSrc = join12(__dirname4, "..", "..", "connectors");
+  if (existsSync10(fromSrc))
     return fromSrc;
   return fromBin;
 }
@@ -24208,21 +24644,21 @@ function normalizeConnectorName(name) {
   return name.startsWith("connect-") ? name.slice("connect-".length) : name;
 }
 function getProjectConnectorsDir(targetDir) {
-  return join11(targetDir, PROJECT_CONNECTORS_DIRNAME);
+  return join12(targetDir, PROJECT_CONNECTORS_DIRNAME);
 }
 function getEnablementManifestPath(targetDir) {
-  return join11(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
+  return join12(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
 }
 function getLegacyInstallPath(targetDir, name) {
-  return join11(getProjectConnectorsDir(targetDir), `connect-${normalizeConnectorName(name)}`);
+  return join12(getProjectConnectorsDir(targetDir), `connect-${normalizeConnectorName(name)}`);
 }
 function loadEnablementManifest(targetDir) {
   const manifestPath = getEnablementManifestPath(targetDir);
-  if (!existsSync9(manifestPath)) {
+  if (!existsSync10(manifestPath)) {
     return null;
   }
   try {
-    const raw = JSON.parse(readFileSync6(manifestPath, "utf-8"));
+    const raw = JSON.parse(readFileSync7(manifestPath, "utf-8"));
     if (!Array.isArray(raw.connectors)) {
       return null;
     }
@@ -24238,11 +24674,11 @@ function loadEnablementManifest(targetDir) {
 }
 function getLegacyInstalledConnectors(targetDir) {
   const connectorsDir = getProjectConnectorsDir(targetDir);
-  if (!existsSync9(connectorsDir)) {
+  if (!existsSync10(connectorsDir)) {
     return [];
   }
-  return readdirSync5(connectorsDir).filter((entry) => {
-    const fullPath = join11(connectorsDir, entry);
+  return readdirSync6(connectorsDir).filter((entry) => {
+    const fullPath = join12(connectorsDir, entry);
     return entry.startsWith("connect-") && statSync3(fullPath).isDirectory();
   }).map((entry) => entry.replace("connect-", "")).sort();
 }
@@ -24251,7 +24687,7 @@ function getEnabledConnectors(targetDir) {
   return [...new Set([...manifestConnectors, ...getLegacyInstalledConnectors(targetDir)])].sort();
 }
 function updateConnectorsIndex(connectorsDir, connectors18) {
-  const indexPath = join11(connectorsDir, ENABLEMENT_INDEX_FILENAME);
+  const indexPath = join12(connectorsDir, ENABLEMENT_INDEX_FILENAME);
   const connectorList = connectors18.map((connector) => `  "${connector}",`).join(`
 `);
   const content = `/**
@@ -24267,28 +24703,28 @@ ${connectorList}
 
 export type EnabledConnectorName = typeof enabledConnectors[number];
 `;
-  writeFileSync5(indexPath, content);
+  writeFileSync6(indexPath, content);
 }
 function writeEnablementManifest(targetDir, connectors18) {
   const connectorsDir = getProjectConnectorsDir(targetDir);
-  mkdirSync6(connectorsDir, { recursive: true });
+  mkdirSync7(connectorsDir, { recursive: true });
   const manifest = {
     version: 1,
     mode: "internal",
     updatedAt: new Date().toISOString(),
     connectors: [...new Set(connectors18.map((value) => normalizeConnectorName(value)))].sort()
   };
-  writeFileSync5(getEnablementManifestPath(targetDir), JSON.stringify(manifest, null, 2) + `
+  writeFileSync6(getEnablementManifestPath(targetDir), JSON.stringify(manifest, null, 2) + `
 `);
   updateConnectorsIndex(connectorsDir, manifest.connectors);
 }
 function getConnectorPath(name) {
   const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  return join11(CONNECTORS_DIR, connectorName);
+  return join12(CONNECTORS_DIR, connectorName);
 }
 function connectorExists(name) {
   const normalizedName = normalizeConnectorName(name);
-  return hasInternalConnectorDefinition(normalizedName) || existsSync9(getConnectorPath(normalizedName));
+  return hasInternalConnectorDefinition(normalizedName) || existsSync10(getConnectorPath(normalizedName));
 }
 function installConnector(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
@@ -24321,7 +24757,7 @@ function installConnector(name, options = {}) {
   try {
     const nextEnabled = [...new Set([...installed, normalizedName])].sort();
     writeEnablementManifest(targetDir, nextEnabled);
-    if (overwrite && existsSync9(legacyInstallPath)) {
+    if (overwrite && existsSync10(legacyInstallPath)) {
       rmSync2(legacyInstallPath, { recursive: true });
     }
     return {
@@ -24356,9 +24792,9 @@ function parseConnectorDocs(raw) {
 function getConnectorDocs(name) {
   const normalizedName = normalizeConnectorName(name);
   const connectorPath = getConnectorPath(normalizedName);
-  const claudeMdPath = join11(connectorPath, "CLAUDE.md");
-  if (existsSync9(claudeMdPath)) {
-    return parseConnectorDocs(readFileSync6(claudeMdPath, "utf-8"));
+  const claudeMdPath = join12(connectorPath, "CLAUDE.md");
+  if (existsSync10(claudeMdPath)) {
+    return parseConnectorDocs(readFileSync7(claudeMdPath, "utf-8"));
   }
   const internalDocs = getInternalConnectorDefinition(normalizedName)?.docsMarkdown;
   if (internalDocs) {
@@ -24402,7 +24838,7 @@ function removeConnector(name, targetDir = process.cwd()) {
   const nextEnabled = installed.filter((connector) => connector !== normalizedName);
   writeEnablementManifest(targetDir, nextEnabled);
   const legacyInstallPath = getLegacyInstallPath(targetDir, normalizedName);
-  if (existsSync9(legacyInstallPath)) {
+  if (existsSync10(legacyInstallPath)) {
     rmSync2(legacyInstallPath, { recursive: true });
   }
   return true;
@@ -24484,13 +24920,13 @@ var init_usage = __esm(() => {
 });
 
 // src/lib/lock.ts
-import { openSync, closeSync, unlinkSync, existsSync as existsSync10, statSync as statSync4 } from "fs";
-import { join as join12 } from "path";
-import { mkdirSync as mkdirSync7 } from "fs";
+import { openSync, closeSync, unlinkSync, existsSync as existsSync11, statSync as statSync4 } from "fs";
+import { join as join13 } from "path";
+import { mkdirSync as mkdirSync8 } from "fs";
 function lockPath(connector) {
-  const dir = join12(getConnectorsHome(), `connect-${connector}`);
-  mkdirSync7(dir, { recursive: true });
-  return join12(dir, ".write.lock");
+  const dir = join13(getConnectorsHome(), `connect-${connector}`);
+  mkdirSync8(dir, { recursive: true });
+  return join13(dir, ".write.lock");
 }
 function isStale(path) {
   try {
@@ -24501,7 +24937,7 @@ function isStale(path) {
   }
 }
 function tryAcquire(path) {
-  if (existsSync10(path) && isStale(path)) {
+  if (existsSync11(path) && isStale(path)) {
     try {
       unlinkSync(path);
     } catch {}
@@ -24550,8 +24986,8 @@ var init_lock = __esm(() => {
 });
 
 // src/server/auth.ts
-import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8, readdirSync as readdirSync6, rmSync as rmSync3, statSync as statSync5 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync9, readdirSync as readdirSync7, rmSync as rmSync3, statSync as statSync5 } from "fs";
+import { join as join14 } from "path";
 function getAuthType(name) {
   const docs = getConnectorDocs(name);
   if (!docs?.auth)
@@ -24565,14 +25001,14 @@ function getAuthType(name) {
 }
 function getConnectorConfigDir(name) {
   const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  return join13(getConnectorsHome(), connectorName);
+  return join14(getConnectorsHome(), connectorName);
 }
 function getCurrentProfile2(name) {
   const configDir = getConnectorConfigDir(name);
-  const currentProfileFile = join13(configDir, "current_profile");
-  if (existsSync11(currentProfileFile)) {
+  const currentProfileFile = join14(configDir, "current_profile");
+  if (existsSync12(currentProfileFile)) {
     try {
-      return readFileSync7(currentProfileFile, "utf-8").trim() || "default";
+      return readFileSync8(currentProfileFile, "utf-8").trim() || "default";
     } catch {
       return "default";
     }
@@ -24584,16 +25020,16 @@ function loadProfileConfig(name) {
   const profile = getCurrentProfile2(name);
   let flatConfig = {};
   let dirConfig = {};
-  const profileFile = join13(configDir, "profiles", `${profile}.json`);
-  if (existsSync11(profileFile)) {
+  const profileFile = join14(configDir, "profiles", `${profile}.json`);
+  if (existsSync12(profileFile)) {
     try {
-      flatConfig = JSON.parse(readFileSync7(profileFile, "utf-8"));
+      flatConfig = JSON.parse(readFileSync8(profileFile, "utf-8"));
     } catch {}
   }
-  const profileDirConfig = join13(configDir, "profiles", profile, "config.json");
-  if (existsSync11(profileDirConfig)) {
+  const profileDirConfig = join14(configDir, "profiles", profile, "config.json");
+  if (existsSync12(profileDirConfig)) {
     try {
-      dirConfig = JSON.parse(readFileSync7(profileDirConfig, "utf-8"));
+      dirConfig = JSON.parse(readFileSync8(profileDirConfig, "utf-8"));
     } catch {}
   }
   if (Object.keys(flatConfig).length === 0 && Object.keys(dirConfig).length === 0) {
@@ -24601,13 +25037,13 @@ function loadProfileConfig(name) {
   }
   return { ...flatConfig, ...dirConfig };
 }
-function loadTokens2(name) {
+function loadTokens3(name) {
   const configDir = getConnectorConfigDir(name);
   const profile = getCurrentProfile2(name);
-  const tokensFile = join13(configDir, "profiles", profile, "tokens.json");
-  if (existsSync11(tokensFile)) {
+  const tokensFile = join14(configDir, "profiles", profile, "tokens.json");
+  if (existsSync12(tokensFile)) {
     try {
-      return JSON.parse(readFileSync7(tokensFile, "utf-8"));
+      return JSON.parse(readFileSync8(tokensFile, "utf-8"));
     } catch {
       return null;
     }
@@ -24646,7 +25082,7 @@ function getAuthStatus(name) {
   const authType = getAuthType(name);
   const docs = getConnectorDocs(name);
   const oauthConfig = authType === "oauth" ? getOAuthConfig(name) : {};
-  const tokens = authType === "oauth" ? loadTokens2(name) : null;
+  const tokens = authType === "oauth" ? loadTokens3(name) : null;
   const profileConfig = authType === "oauth" ? loadProfileConfig(name) : {};
   const envVars = (docs?.envVars || []).map((v) => ({
     variable: v.variable,
@@ -24695,43 +25131,43 @@ function _saveApiKey(name, key, field) {
   const profile = getCurrentProfile2(name);
   const keyField = field || guessKeyField(name);
   if (keyField === "clientId" || keyField === "clientSecret") {
-    const credentialsFile = join13(configDir, "credentials.json");
-    mkdirSync8(configDir, { recursive: true });
+    const credentialsFile = join14(configDir, "credentials.json");
+    mkdirSync9(configDir, { recursive: true });
     let creds = {};
-    if (existsSync11(credentialsFile)) {
+    if (existsSync12(credentialsFile)) {
       try {
-        creds = JSON.parse(readFileSync7(credentialsFile, "utf-8"));
+        creds = JSON.parse(readFileSync8(credentialsFile, "utf-8"));
       } catch {}
     }
     creds[keyField] = key;
-    writeFileSync6(credentialsFile, JSON.stringify(creds, null, 2));
+    writeFileSync7(credentialsFile, JSON.stringify(creds, null, 2));
     return;
   }
-  const profileFile = join13(configDir, "profiles", `${profile}.json`);
-  const profileDir = join13(configDir, "profiles", profile);
-  if (existsSync11(profileFile)) {
+  const profileFile = join14(configDir, "profiles", `${profile}.json`);
+  const profileDir = join14(configDir, "profiles", profile);
+  if (existsSync12(profileFile)) {
     let config2 = {};
     try {
-      config2 = JSON.parse(readFileSync7(profileFile, "utf-8"));
+      config2 = JSON.parse(readFileSync8(profileFile, "utf-8"));
     } catch {}
     config2[keyField] = key;
-    writeFileSync6(profileFile, JSON.stringify(config2, null, 2));
+    writeFileSync7(profileFile, JSON.stringify(config2, null, 2));
     return;
   }
-  if (existsSync11(profileDir)) {
-    const configFile = join13(profileDir, "config.json");
+  if (existsSync12(profileDir)) {
+    const configFile = join14(profileDir, "config.json");
     let config2 = {};
-    if (existsSync11(configFile)) {
+    if (existsSync12(configFile)) {
       try {
-        config2 = JSON.parse(readFileSync7(configFile, "utf-8"));
+        config2 = JSON.parse(readFileSync8(configFile, "utf-8"));
       } catch {}
     }
     config2[keyField] = key;
-    writeFileSync6(configFile, JSON.stringify(config2, null, 2));
+    writeFileSync7(configFile, JSON.stringify(config2, null, 2));
     return;
   }
-  mkdirSync8(profileDir, { recursive: true });
-  writeFileSync6(join13(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
+  mkdirSync9(profileDir, { recursive: true });
+  writeFileSync7(join14(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
 }
 function guessKeyField(name) {
   const docs = getConnectorDocs(name);
@@ -24749,10 +25185,10 @@ function guessKeyField(name) {
 }
 function getOAuthConfig(name) {
   const configDir = getConnectorConfigDir(name);
-  const credentialsFile = join13(configDir, "credentials.json");
-  if (existsSync11(credentialsFile)) {
+  const credentialsFile = join14(configDir, "credentials.json");
+  if (existsSync12(credentialsFile)) {
     try {
-      const creds = JSON.parse(readFileSync7(credentialsFile, "utf-8"));
+      const creds = JSON.parse(readFileSync8(credentialsFile, "utf-8"));
       return { clientId: creds.clientId, clientSecret: creds.clientSecret };
     } catch {}
   }
@@ -24765,17 +25201,17 @@ function getOAuthConfig(name) {
 function saveOAuthTokens(name, tokens) {
   const configDir = getConnectorConfigDir(name);
   const profile = getCurrentProfile2(name);
-  const profileDir = join13(configDir, "profiles", profile);
-  mkdirSync8(profileDir, { recursive: true });
-  const tokensFile = join13(profileDir, "tokens.json");
-  writeFileSync6(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
+  const profileDir = join14(configDir, "profiles", profile);
+  mkdirSync9(profileDir, { recursive: true });
+  const tokensFile = join14(profileDir, "tokens.json");
+  writeFileSync7(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 async function refreshOAuthToken(name) {
   return withWriteLock(name, () => _refreshOAuthToken(name));
 }
 async function _refreshOAuthToken(name) {
   const oauthConfig = getOAuthConfig(name);
-  const currentTokens = loadTokens2(name);
+  const currentTokens = loadTokens3(name);
   if (!oauthConfig.clientId || !oauthConfig.clientSecret) {
     throw new Error("OAuth credentials not configured for " + name);
   }
@@ -24868,16 +25304,16 @@ __export(exports_runner, {
   buildEnvWithCredentials: () => buildEnvWithCredentials,
   buildConnectorOperationArgs: () => buildConnectorOperationArgs
 });
-import { existsSync as existsSync13, readdirSync as readdirSync7 } from "fs";
-import { join as join15, dirname as dirname7 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync8 } from "fs";
+import { join as join16, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { spawn as spawn2 } from "child_process";
 function resolveConnectorsDir2() {
-  const fromBin = join15(__dirname5, "..", "connectors");
-  if (existsSync13(fromBin))
+  const fromBin = join16(__dirname5, "..", "connectors");
+  if (existsSync14(fromBin))
     return fromBin;
-  const fromSrc = join15(__dirname5, "..", "..", "connectors");
-  if (existsSync13(fromSrc))
+  const fromSrc = join16(__dirname5, "..", "..", "connectors");
+  if (existsSync14(fromSrc))
     return fromSrc;
   return fromBin;
 }
@@ -24922,7 +25358,7 @@ function buildEnvWithCredentials(connectorName, baseEnv) {
   }
   if (getAuthType(connectorName) === "oauth") {
     const oauthConfig = getOAuthConfig(connectorName);
-    const tokens = loadTokens2(connectorName);
+    const tokens = loadTokens3(connectorName);
     for (const { variable } of getEnvVars(connectorName)) {
       if (env[variable])
         continue;
@@ -24943,9 +25379,9 @@ function buildEnvWithCredentials(connectorName, baseEnv) {
 }
 function getConnectorCliPath(name) {
   const safeName = name.replace(/[^a-z0-9-]/g, "");
-  const connectorDir = join15(CONNECTORS_DIR2, `connect-${safeName}`);
-  const cliPath = join15(connectorDir, "src", "cli", "index.ts");
-  if (existsSync13(cliPath))
+  const connectorDir = join16(CONNECTORS_DIR2, `connect-${safeName}`);
+  const cliPath = join16(connectorDir, "src", "cli", "index.ts");
+  if (existsSync14(cliPath))
     return cliPath;
   return null;
 }
@@ -25217,7 +25653,7 @@ async function getConnectorCommandHelp(name, command) {
 function getConnectorsWithCli() {
   const connectors18 = new Set;
   try {
-    const dirs = readdirSync7(CONNECTORS_DIR2);
+    const dirs = readdirSync8(CONNECTORS_DIR2);
     for (const dir of dirs) {
       if (!dir.startsWith("connect-"))
         continue;
@@ -34251,8 +34687,8 @@ class StdioServerTransport {
 
 // src/lib/registry.ts
 init_builtins();
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
-import { join as join9, dirname as dirname5 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { join as join10, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/fuzzy.ts
@@ -40523,17 +40959,17 @@ function loadConnectorVersions() {
   versionsLoaded = true;
   const thisDir = dirname5(fileURLToPath3(import.meta.url));
   const candidates = [
-    join9(thisDir, "..", "connectors"),
-    join9(thisDir, "..", "..", "connectors")
+    join10(thisDir, "..", "connectors"),
+    join10(thisDir, "..", "..", "connectors")
   ];
-  const connectorsDir = candidates.find((d) => existsSync7(d));
+  const connectorsDir = candidates.find((d) => existsSync8(d));
   if (!connectorsDir)
     return;
   for (const connector of CONNECTORS) {
     try {
-      const pkgPath = join9(connectorsDir, `connect-${connector.name}`, "package.json");
-      if (existsSync7(pkgPath)) {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+      const pkgPath = join10(connectorsDir, `connect-${connector.name}`, "package.json");
+      if (existsSync8(pkgPath)) {
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         connector.version = pkg.version || "0.0.0";
         continue;
       }
@@ -40857,8 +41293,8 @@ function registerManagementTools(server, stripped) {
 init_zod();
 init_auth();
 init_database();
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
+import { join as join15 } from "path";
 import { spawn } from "child_process";
 function registerAuthTools(server, stripped) {
   server.registerTool("connector_auth_status", {
@@ -40977,7 +41413,7 @@ function registerAuthTools(server, stripped) {
         };
       }
     }
-    const tokens = loadTokens2(name);
+    const tokens = loadTokens3(name);
     if (tokens?.accessToken && tokens?.refreshToken) {
       if (tokens.expiresAt && Date.now() < tokens.expiresAt - 60000) {
         const mins = Math.floor((tokens.expiresAt - Date.now()) / 60000);
@@ -40995,7 +41431,7 @@ function registerAuthTools(server, stripped) {
     if (noBrowser) {
       const connectorsHome = getConnectorsHome();
       const connectorDirName = name.startsWith("connect-") ? name : `connect-${name}`;
-      const tokensPath = join14(connectorsHome, connectorDirName, "profiles", "default", "tokens.json");
+      const tokensPath = join15(connectorsHome, connectorDirName, "profiles", "default", "tokens.json");
       let serverRunning = false;
       try {
         await fetch(`http://localhost:${serverPort}/api/connectors`);
@@ -41014,7 +41450,7 @@ function registerAuthTools(server, stripped) {
       const maxAttempts = 120;
       while (attempts < maxAttempts) {
         await new Promise((resolve) => setTimeout(resolve, 500));
-        if (existsSync12(tokensPath)) {
+        if (existsSync13(tokensPath)) {
           break;
         }
         attempts++;
@@ -41033,7 +41469,7 @@ function registerAuthTools(server, stripped) {
         };
       }
       try {
-        const tokenData = JSON.parse(readFileSync8(tokensPath, "utf-8"));
+        const tokenData = JSON.parse(readFileSync9(tokensPath, "utf-8"));
         return {
           content: [{
             type: "text",