@hasna/connectors 1.3.32 → 1.3.33

package/dist/index.js

@@ -15,8 +15,8 @@ var __export = (target, all) => {
 };
 
 // src/lib/registry.ts
-import { existsSync as existsSync8, readFileSync as readFileSync3 } from "fs";
-import { join as join9, dirname as dirname5 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { join as join11, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/core/errors.ts
@@ -42,7 +42,7 @@ class ConnectorOperationNotFoundError extends Error {
 
 // src/core/connector.ts
 var CONNECTOR_NAME_RE = /^[a-z0-9-]+$/;
-var OPERATION_NAME_RE = /^[a-z0-9:_-]+$/;
+var OPERATION_NAME_RE = /^[A-Za-z0-9:._-]+$/;
 function defineConnector(definition) {
   const { meta, auth, operations } = definition;
   if (!CONNECTOR_NAME_RE.test(meta.name)) {
@@ -4113,10 +4113,10 @@ var NEVER = INVALID;
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
 function resolveGithubConnectorDir() {
   const candidates = [
-    join(__dirname2, "..", "..", "..", "connectors", "connect-github"),
-    join(__dirname2, "..", "..", "connectors", "connect-github"),
-    join(__dirname2, "..", "connectors", "connect-github"),
-    join(process.cwd(), "connectors", "connect-github")
+    join(__dirname2, "..", "..", "..", "connectors", "github"),
+    join(__dirname2, "..", "..", "connectors", "github"),
+    join(__dirname2, "..", "connectors", "github"),
+    join(process.cwd(), "connectors", "github")
   ];
   for (const candidate of candidates) {
     if (existsSync(candidate)) {
@@ -4966,10 +4966,805 @@ var githubConnector = defineConnector({
     }
   }
 });
+
+// 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";
+var GMAIL_API_BASE = "https://gmail.googleapis.com/gmail/v1";
+var TOKEN_URL = "https://oauth2.googleapis.com/token";
+var REFRESH_BUFFER_MS = 5 * 60 * 1000;
+var MAX_GMAIL_RETRIES = 5;
+var 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()
+});
+var 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()
+});
+var readMessageSchema = messageIdSchema.extend({
+  body: exports_external.boolean().optional(),
+  html: exports_external.boolean().optional(),
+  format: exports_external.enum(["full", "metadata", "minimal", "raw"]).optional()
+});
+var attachmentListSchema = messageIdSchema;
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var 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
+      })
+    }
+  }
+});
+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 requestJson(profile, path, params, options = {}) {
+  const token = await getValidAccessToken(profile);
+  const url = new URL(`${GMAIL_API_BASE}${path}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null && value !== "")
+      url.searchParams.append(key, String(value));
+  }
+  let lastError;
+  for (let attempt = 0;attempt <= MAX_GMAIL_RETRIES; attempt++) {
+    let response;
+    try {
+      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
+      });
+    } catch (error2) {
+      lastError = error2 instanceof Error ? error2.message : String(error2);
+      if (attempt >= MAX_GMAIL_RETRIES)
+        throw error2;
+      await sleep(gmailBackoffDelayMs(attempt));
+      continue;
+    }
+    const text = await response.text();
+    const data = text ? JSON.parse(text) : {};
+    if (response.ok)
+      return data;
+    const error = data;
+    lastError = error.error?.message ?? response.statusText;
+    if (!isRetryableGmailResponse(response.status, error) || attempt >= MAX_GMAIL_RETRIES) {
+      throw new Error(`Gmail request failed (${response.status}): ${lastError}`);
+    }
+    await sleep(gmailBackoffDelayMs(attempt, response.headers.get("retry-after")));
+  }
+  throw new Error(`Gmail request failed: ${lastError ?? "unknown error"}`);
+}
+function isRetryableGmailResponse(status, error) {
+  if ([429, 500, 502, 503, 504].includes(status))
+    return true;
+  const reasons = error.error?.errors?.map((entry) => entry.reason) ?? [];
+  return reasons.some((reason) => reason === "rateLimitExceeded" || reason === "userRateLimitExceeded");
+}
+function gmailBackoffDelayMs(attempt, retryAfter = null) {
+  if (retryAfter) {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0)
+      return seconds * 1000;
+  }
+  const base = Number(process.env.CONNECTORS_GMAIL_RETRY_BASE_MS ?? "1000");
+  const baseMs = Number.isFinite(base) && base >= 0 ? base : 1000;
+  const jitterMs = Math.floor(Math.random() * 1000);
+  return Math.min(2 ** attempt * baseMs + jitterMs, 64000);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function getValidAccessToken(profile) {
+  if (process.env.GMAIL_ACCESS_TOKEN)
+    return process.env.GMAIL_ACCESS_TOKEN;
+  const tokens = loadTokens(profile);
+  if (!tokens?.accessToken && !tokens?.refreshToken) {
+    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;
+  if (!tokens.refreshToken)
+    return tokens.accessToken ?? "";
+  return (await refreshAccessToken(profile, tokens)).accessToken ?? "";
+}
+async function refreshAccessToken(profile, currentTokens) {
+  const credentials = loadCredentials(profile);
+  if (!credentials.clientId || !credentials.clientSecret)
+    throw new Error("Gmail OAuth credentials are not configured. Run: connectors auth gmail");
+  if (!currentTokens.refreshToken)
+    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" },
+    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(`Gmail 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
+  };
+  saveTokens(profile, tokens);
+  return tokens;
+}
+function listProfiles() {
+  const profiles = new Set;
+  for (const baseDir of configDirs()) {
+    const profilesDir = join2(baseDir, "profiles");
+    if (!existsSync2(profilesDir))
+      continue;
+    for (const entry of readdirSync(profilesDir, { withFileTypes: true })) {
+      if (entry.isDirectory())
+        profiles.add(entry.name);
+      if (entry.isFile() && entry.name.endsWith(".json"))
+        profiles.add(basename(entry.name, ".json"));
+    }
+  }
+  return Array.from(profiles).sort((a, b) => a.localeCompare(b));
+}
+function loadCredentials(profile) {
+  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()) {
+    const credentials = {
+      ...readJson(join2(baseDir, "credentials.json")),
+      ...readJson(join2(baseDir, "profiles", profile, "config.json"))
+    };
+    if (credentials.clientId || credentials.clientSecret)
+      return credentials;
+  }
+  return {};
+}
+function loadTokens(profile) {
+  for (const baseDir of configDirs()) {
+    const fromProfile = readJson(join2(baseDir, "profiles", profile, "tokens.json"));
+    if (fromProfile)
+      return fromProfile;
+    const flat = readJson(join2(baseDir, "profiles", `${profile}.json`));
+    if (flat)
+      return flat.tokens ?? (flat.accessToken || flat.refreshToken ? flat : null);
+  }
+  return null;
+}
+function saveTokens(profile, tokens) {
+  const baseDir = configDirs().find((dir) => existsSync2(dir)) ?? configDirs()[0];
+  const profileDir = join2(baseDir, "profiles", profile);
+  mkdirSync(profileDir, { recursive: true });
+  writeFileSync(join2(profileDir, "tokens.json"), JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+function configDirs() {
+  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, "gmail"), join2(baseDir, "connect-gmail")];
+}
+function readJson(path) {
+  if (!existsSync2(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    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, "_");
+}
+
+// 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";
+var DRIVE_API_BASE = "https://www.googleapis.com/drive/v3";
+var TOKEN_URL2 = "https://oauth2.googleapis.com/token";
+var REFRESH_BUFFER_MS2 = 5 * 60 * 1000;
+var DEFAULT_FILE_FIELDS = [
+  "id",
+  "name",
+  "mimeType",
+  "parents",
+  "version",
+  "md5Checksum",
+  "size",
+  "modifiedTime",
+  "createdTime",
+  "trashed",
+  "webViewLink",
+  "webContentLink"
+].join(",");
+var DEFAULT_EXPORT_FORMATS = {
+  document: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  spreadsheet: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  presentation: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  drawing: "image/png"
+};
+var EXPORT_EXTENSIONS = {
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+  "application/pdf": ".pdf",
+  "text/plain": ".txt",
+  "text/csv": ".csv",
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/svg+xml": ".svg"
+};
+var listFilesSchema = exports_external.object({
+  pageSize: exports_external.coerce.number().int().positive().max(1000).optional(),
+  pageToken: exports_external.string().optional(),
+  q: exports_external.string().optional(),
+  fields: exports_external.string().optional(),
+  orderBy: exports_external.string().optional(),
+  corpora: exports_external.enum(["user", "drive", "allDrives"]).optional(),
+  driveId: exports_external.string().optional(),
+  supportsAllDrives: exports_external.boolean().optional(),
+  includeItemsFromAllDrives: exports_external.boolean().optional()
+});
+var listDrivesSchema = exports_external.object({
+  pageSize: exports_external.coerce.number().int().positive().max(100).optional(),
+  pageToken: exports_external.string().optional(),
+  q: exports_external.string().optional()
+});
+var fileIdSchema = exports_external.object({
+  fileId: exports_external.string(),
+  fields: exports_external.string().optional()
+});
+var downloadSchema = exports_external.object({
+  fileId: exports_external.string(),
+  file: exports_external.object({
+    id: exports_external.string(),
+    name: exports_external.string(),
+    mimeType: exports_external.string()
+  }).optional(),
+  exportMimeType: exports_external.string().optional()
+});
+var profilesStatusSchema = exports_external.object({
+  profile: exports_external.string().optional()
+});
+var googleDriveConnector = defineConnector({
+  meta: {
+    name: "googledrive",
+    displayName: "Google Drive",
+    description: "Profile-aware Google Drive discovery and file download operations.",
+    category: "storage",
+    tags: ["google", "drive", "files", "storage"]
+  },
+  auth: {
+    type: "oauth2",
+    supportsProfiles: true,
+    fields: [
+      { key: "clientId", env: "GOOGLE_CLIENT_ID", label: "OAuth client ID" },
+      { key: "clientSecret", env: "GOOGLE_CLIENT_SECRET", label: "OAuth client secret", secret: true }
+    ]
+  },
+  createContext: ({ profile }) => ({ profile: profile || "default" }),
+  operations: {
+    "profiles.list": {
+      summary: "List configured Google Drive profiles.",
+      execute: () => ({ profiles: listProfiles2() })
+    },
+    "profiles.status": {
+      summary: "List Google Drive profile authentication status.",
+      inputSchema: profilesStatusSchema,
+      execute: (_ctx, input) => ({ profiles: listProfileStatuses(input.profile) })
+    },
+    "files.list": {
+      summary: "List Google Drive files.",
+      inputSchema: listFilesSchema,
+      execute: async ({ context }, input) => requestJson2(context.profile, "/files", {
+        pageSize: input.pageSize ?? 1000,
+        pageToken: input.pageToken,
+        q: input.q,
+        fields: input.fields ?? `nextPageToken,files(${DEFAULT_FILE_FIELDS})`,
+        orderBy: input.orderBy ?? "modifiedTime desc",
+        corpora: input.corpora,
+        driveId: input.driveId,
+        supportsAllDrives: input.supportsAllDrives ?? true,
+        includeItemsFromAllDrives: input.includeItemsFromAllDrives ?? false
+      })
+    },
+    "files.get": {
+      summary: "Get Google Drive file metadata.",
+      inputSchema: fileIdSchema,
+      execute: async ({ context }, input) => requestJson2(context.profile, `/files/${encodeURIComponent(input.fileId)}`, {
+        fields: input.fields ?? DEFAULT_FILE_FIELDS,
+        supportsAllDrives: true
+      })
+    },
+    "files.download": {
+      summary: "Download or export a Google Drive file as base64 content.",
+      inputSchema: downloadSchema,
+      execute: async ({ context }, input) => {
+        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";
+        return {
+          dataBase64: Buffer.from(data).toString("base64"),
+          filename: exportMimeType ? `${file.name}${extensionForMimeType(exportMimeType)}` : file.name,
+          mimeType
+        };
+      }
+    },
+    "drives.list": {
+      summary: "List Google shared drives.",
+      inputSchema: listDrivesSchema,
+      execute: async ({ context }, input) => requestJson2(context.profile, "/drives", {
+        pageSize: input.pageSize ?? 100,
+        pageToken: input.pageToken,
+        q: input.q
+      })
+    }
+  }
+});
+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 listProfileStatuses(profile) {
+  const profiles = profile ? [profile] : listProfiles2();
+  const uniqueProfiles = profiles.length ? profiles : ["default"];
+  const now = Date.now();
+  return uniqueProfiles.map((name) => {
+    const tokens = loadTokens2(name);
+    const credentials = loadCredentials2(name);
+    const hasAccessToken = Boolean(tokens?.accessToken || process.env.GOOGLE_ACCESS_TOKEN);
+    const hasRefreshToken = Boolean(tokens?.refreshToken);
+    const hasOAuthCredentials = Boolean(credentials.clientId && credentials.clientSecret);
+    const expiresAt = tokens?.expiresAt ?? null;
+    const expired = Boolean(expiresAt && now >= expiresAt - REFRESH_BUFFER_MS2);
+    const authenticated = Boolean(process.env.GOOGLE_ACCESS_TOKEN || hasRefreshToken || hasAccessToken && !expired);
+    const configured = authenticated || hasOAuthCredentials;
+    const authRequired = !authenticated || expired && !hasRefreshToken;
+    return {
+      profile: name,
+      configured,
+      authenticated,
+      expired,
+      expiresAt,
+      hasAccessToken,
+      hasRefreshToken,
+      hasOAuthCredentials,
+      authRequired,
+      message: authRequired ? `Google Drive profile "${name}" needs authentication. Run: connectors auth googledrive` : expired ? `Google Drive profile "${name}" access token is expired but can refresh.` : `Google Drive profile "${name}" is authenticated.`
+    };
+  });
+}
+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, "googledrive"), join3(baseDir, "connect-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;
+  if (googleMimeType.endsWith(".spreadsheet"))
+    return DEFAULT_EXPORT_FORMATS.spreadsheet;
+  if (googleMimeType.endsWith(".presentation"))
+    return DEFAULT_EXPORT_FORMATS.presentation;
+  if (googleMimeType.endsWith(".drawing"))
+    return DEFAULT_EXPORT_FORMATS.drawing;
+  throw new Error(`Cannot export Google Workspace file type: ${googleMimeType}`);
+}
+function extensionForMimeType(mimeType) {
+  return EXPORT_EXTENSIONS[mimeType] ?? "";
+}
+function extractGoogleError(body) {
+  if (!body)
+    return "";
+  try {
+    const parsed = JSON.parse(body);
+    return parsed.error?.message ?? body;
+  } catch {
+    return body;
+  }
+}
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.3.24",
+  version: "1.3.32",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {
@@ -5057,35 +5852,39 @@ var package_default = {
 
 // src/core/connectors/imessage.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync2,
-  readdirSync as readdirSync5,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync6,
   rmSync,
-  statSync as statSync2,
-  writeFileSync as writeFileSync2
+  statSync as statSync3,
+  writeFileSync as writeFileSync4
 } from "fs";
+import { join as join9 } from "path";
+
+// src/lib/connector-resolver.ts
+import { existsSync as existsSync6, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
 import { join as join7 } from "path";
 
 // node_modules/@hasna/cloud/dist/index.js
 import { createRequire } from "module";
 import { Database } from "bun:sqlite";
 import {
-  existsSync as existsSync2,
-  mkdirSync,
-  readdirSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync3,
   copyFileSync
 } from "fs";
-import { homedir } from "os";
-import { join as join2, relative } from "path";
-import { existsSync as existsSync22, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join22 } from "path";
-import { readdirSync as readdirSync2, existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
 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 homedir32 } 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";
 var __create = Object.create;
@@ -14251,17 +15050,17 @@ var init_zod = __esm(() => {
   init_external();
 });
 function getDataDir(serviceName) {
-  const dir = join2(HASNA_DIR, serviceName);
-  mkdirSync(dir, { recursive: true });
+  const dir = join4(HASNA_DIR, serviceName);
+  mkdirSync3(dir, { recursive: true });
   return dir;
 }
 function getDbPath(serviceName) {
   const dir = getDataDir(serviceName);
-  return join2(dir, `${serviceName}.db`);
+  return join4(dir, `${serviceName}.db`);
 }
 var HASNA_DIR;
 var init_dotfile = __esm(() => {
-  HASNA_DIR = join2(homedir(), ".hasna");
+  HASNA_DIR = join4(homedir3(), ".hasna");
 });
 var exports_config = {};
 __export2(exports_config, {
@@ -14284,15 +15083,15 @@ function getCloudConfig() {
     return CloudConfigSchema.parse({});
   }
   try {
-    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    const raw = readFileSync3(CONFIG_PATH, "utf-8");
     return CloudConfigSchema.parse(JSON.parse(raw));
   } catch {
     return CloudConfigSchema.parse({});
   }
 }
 function saveCloudConfig(config) {
-  mkdirSync2(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+  mkdirSync22(CONFIG_DIR, { recursive: true });
+  writeFileSync3(CONFIG_PATH, JSON.stringify(config, null, 2) + `
 `, "utf-8");
 }
 function getConnectionString(dbName) {
@@ -14340,7 +15139,7 @@ var init_config = __esm(() => {
       schedule_minutes: exports_external2.number().default(0)
     }).default({})
   });
-  CONFIG_DIR = join22(homedir2(), ".hasna", "cloud");
+  CONFIG_DIR = join22(homedir22(), ".hasna", "cloud");
   CONFIG_PATH = join22(CONFIG_DIR, "config.json");
 });
 var exports_discover = {};
@@ -14356,11 +15155,11 @@ function isSyncExcludedTable(table) {
   return SYNC_EXCLUDED_TABLE_PATTERNS.some((p) => p.test(table));
 }
 function discoverServices() {
-  const dataDir = join3(homedir3(), ".hasna");
-  if (!existsSync3(dataDir))
+  const dataDir = join32(homedir32(), ".hasna");
+  if (!existsSync32(dataDir))
     return [];
   try {
-    const entries = readdirSync2(dataDir, { withFileTypes: true });
+    const entries = readdirSync22(dataDir, { withFileTypes: true });
     return entries.filter((e) => {
       if (!e.isDirectory())
         return false;
@@ -14378,24 +15177,24 @@ function discoverSyncableServices() {
   return local.filter((s) => pgSet.has(s));
 }
 function getServiceDbPath(service) {
-  const dataDir = join3(homedir3(), ".hasna", service);
-  if (!existsSync3(dataDir))
+  const dataDir = join32(homedir32(), ".hasna", service);
+  if (!existsSync32(dataDir))
     return null;
   const candidates = [
-    join3(dataDir, `${service}.db`),
-    join3(dataDir, "data.db"),
-    join3(dataDir, "database.db")
+    join32(dataDir, `${service}.db`),
+    join32(dataDir, "data.db"),
+    join32(dataDir, "database.db")
   ];
   try {
-    const files = readdirSync2(dataDir);
+    const files = readdirSync22(dataDir);
     for (const f of files) {
       if (f.endsWith(".db") && !f.endsWith("-wal") && !f.endsWith("-shm")) {
-        candidates.push(join3(dataDir, f));
+        candidates.push(join32(dataDir, f));
       }
     }
   } catch {}
   for (const p of candidates) {
-    if (existsSync3(p))
+    if (existsSync32(p))
       return p;
   }
   return null;
@@ -14575,7 +15374,7 @@ class SyncProgressTracker {
 init_adapter();
 init_config();
 init_discover();
-var AUTO_SYNC_CONFIG_PATH = join4(homedir4(), ".hasna", "cloud", "config.json");
+var AUTO_SYNC_CONFIG_PATH = join42(homedir4(), ".hasna", "cloud", "config.json");
 init_config();
 init_adapter();
 init_dotfile();
@@ -14595,13 +15394,13 @@ init_adapter();
 // src/db/database.ts
 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 {
@@ -14610,7 +15409,7 @@ function mergeDirectoryContents(sourceDir, targetDir) {
         mergeDirectoryContents(sourcePath, targetPath);
         continue;
       }
-      if (!existsSync4(targetPath)) {
+      if (!existsSync5(targetPath)) {
         copyFileSync2(sourcePath, targetPath);
       }
     } catch {}
@@ -14620,7 +15419,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);
@@ -14631,8 +15430,85 @@ function getConnectorsHome() {
 var DB_DIR = getConnectorsHome();
 var DB_PATH = join5(DB_DIR, "connectors.db");
 
+// src/lib/connector-resolver.ts
+var LEGACY_CONNECTOR_PREFIX = "connect-";
+var CONNECTOR_NAME_RE2 = /^[a-z0-9-]+$/;
+function normalizeConnectorName(name) {
+  const trimmed = name.trim().toLowerCase();
+  return trimmed.startsWith(LEGACY_CONNECTOR_PREFIX) ? trimmed.slice(LEGACY_CONNECTOR_PREFIX.length) : trimmed;
+}
+function legacyConnectorName(name) {
+  return `${LEGACY_CONNECTOR_PREFIX}${normalizeConnectorName(name)}`;
+}
+function resolveConnectorName(name) {
+  const canonicalName = normalizeConnectorName(name);
+  const legacyName = legacyConnectorName(canonicalName);
+  return {
+    input: name,
+    canonicalName,
+    legacyName,
+    aliases: canonicalName === legacyName ? [canonicalName] : [canonicalName, legacyName],
+    isLegacyInput: name.trim().toLowerCase().startsWith(LEGACY_CONNECTOR_PREFIX)
+  };
+}
+function isValidConnectorName(name) {
+  const trimmed = name.trim();
+  if (trimmed !== trimmed.toLowerCase())
+    return false;
+  return CONNECTOR_NAME_RE2.test(normalizeConnectorName(trimmed));
+}
+function connectorPackageDirNames(name) {
+  const { canonicalName, legacyName } = resolveConnectorName(name);
+  if (!canonicalName)
+    return [legacyName];
+  return canonicalName === legacyName ? [canonicalName] : [canonicalName, legacyName];
+}
+function resolveConnectorPackagePath(connectorsDir, name) {
+  const resolution = resolveConnectorName(name);
+  const dirNames = connectorPackageDirNames(name);
+  const checkedPaths = dirNames.map((dirName) => join7(connectorsDir, dirName));
+  const existingPath = checkedPaths.find((path) => existsSync6(path)) ?? null;
+  const existingDirName = existingPath ? dirNames[checkedPaths.indexOf(existingPath)] : null;
+  return {
+    ...resolution,
+    connectorsDir,
+    preferredDirName: dirNames[0],
+    preferredPath: checkedPaths[0],
+    existingPath,
+    existingDirName,
+    checkedPaths
+  };
+}
+function getConnectorPackagePath(connectorsDir, name) {
+  const resolved = resolveConnectorPackagePath(connectorsDir, name);
+  return resolved.existingPath ?? resolved.preferredPath;
+}
+function resolveConnectorConfigPaths(name, connectorsHome = getConnectorsHome()) {
+  const resolution = resolveConnectorName(name);
+  const preferredDirName = resolution.canonicalName || resolution.legacyName;
+  const preferredPath = join7(connectorsHome, preferredDirName);
+  const legacyPath = join7(connectorsHome, resolution.legacyName);
+  const paths = preferredPath === legacyPath ? [preferredPath] : [preferredPath, legacyPath];
+  const existingPaths = paths.filter((path) => existsSync6(path));
+  return {
+    ...resolution,
+    connectorsHome,
+    preferredDirName,
+    preferredPath,
+    legacyPath,
+    existingPaths,
+    readPaths: paths
+  };
+}
+function getConnectorConfigDir(name, connectorsHome = getConnectorsHome()) {
+  return resolveConnectorConfigPaths(name, connectorsHome).preferredPath;
+}
+function getConnectorConfigReadDirs(name, connectorsHome = getConnectorsHome()) {
+  return resolveConnectorConfigPaths(name, connectorsHome).readPaths;
+}
+
 // src/core/connectors/imessage.ts
-var CONNECTOR_DIRNAME = "connect-imessage";
+var CONNECTOR_NAME = "imessage";
 var COMMAND_SPECS = [
   {
     name: "profile",
@@ -14756,7 +15632,7 @@ API Key authentication is optional and depends on the bridge deployment. A bridg
 
 ## Data Storage
 
-Connector state is stored under \`~/.hasna/connectors/connect-imessage/\`. Profiles are read from both \`profiles/<name>.json\` and \`profiles/<name>/config.json\` so the connector stays compatible with the shared dashboard auth helpers while remaining fully internal to the one-product repo.
+Connector state is stored under \`~/.hasna/connectors/imessage/\`. Profiles are read from both \`profiles/<name>.json\` and \`profiles/<name>/config.json\` so the connector stays compatible with the shared dashboard auth helpers while remaining fully internal to the one-product repo.
 `;
 var commandInputSchema = exports_external.object({
   args: exports_external.array(exports_external.string()).default([]),
@@ -14792,36 +15668,44 @@ var messageReplyInputSchema = exports_external.object({
   deviceId: exports_external.string().optional()
 });
 function getConfigDir2() {
-  return join7(getConnectorsHome(), CONNECTOR_DIRNAME);
+  return getConnectorConfigDir(CONNECTOR_NAME);
+}
+function getConfigReadDirs() {
+  return getConnectorConfigReadDirs(CONNECTOR_NAME);
 }
 function getProfilesDir() {
-  return join7(getConfigDir2(), "profiles");
+  return join9(getConfigDir2(), "profiles");
 }
 function getCurrentProfile() {
-  const currentProfileFile = join7(getConfigDir2(), "current_profile");
-  if (!existsSync6(currentProfileFile)) {
-    return "default";
-  }
-  try {
-    return readFileSync2(currentProfileFile, "utf-8").trim() || "default";
-  } catch {
-    return "default";
+  for (const configDir of getConfigReadDirs()) {
+    const currentProfileFile = join9(configDir, "current_profile");
+    if (!existsSync7(currentProfileFile))
+      continue;
+    try {
+      return readFileSync4(currentProfileFile, "utf-8").trim() || "default";
+    } catch {
+      return "default";
+    }
   }
+  return "default";
 }
 function setCurrentProfile(profile) {
   const configDir = getConfigDir2();
   mkdirSync5(configDir, { recursive: true });
-  writeFileSync2(join7(configDir, "current_profile"), profile);
+  writeFileSync4(join9(configDir, "current_profile"), profile);
 }
 function getFlatProfilePath(profile) {
-  return join7(getProfilesDir(), `${profile}.json`);
+  return join9(getProfilesDir(), `${profile}.json`);
+}
+function getFlatProfileReadPaths(profile) {
+  return getConfigReadDirs().map((dir) => join9(dir, "profiles", `${profile}.json`));
 }
-function getDirectoryProfilePath(profile) {
-  return join7(getProfilesDir(), profile, "config.json");
+function getDirectoryProfileReadPaths(profile) {
+  return getConfigReadDirs().map((dir) => join9(dir, "profiles", profile, "config.json"));
 }
 function loadJsonFile(path) {
   try {
-    return JSON.parse(readFileSync2(path, "utf-8"));
+    return JSON.parse(readFileSync4(path, "utf-8"));
   } catch {
     return {};
   }
@@ -14837,8 +15721,8 @@ function sanitizeProfileConfig(config) {
   };
 }
 function loadProfile(profile = getCurrentProfile()) {
-  const flatConfig = existsSync6(getFlatProfilePath(profile)) ? loadJsonFile(getFlatProfilePath(profile)) : {};
-  const directoryConfig = existsSync6(getDirectoryProfilePath(profile)) ? loadJsonFile(getDirectoryProfilePath(profile)) : {};
+  const flatConfig = getFlatProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync7(path) ? loadJsonFile(path) : {} }), {});
+  const directoryConfig = getDirectoryProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync7(path) ? loadJsonFile(path) : {} }), {});
   return sanitizeProfileConfig({
     ...flatConfig,
     ...directoryConfig
@@ -14847,32 +15731,33 @@ function loadProfile(profile = getCurrentProfile()) {
 function writeProfile(profile, config) {
   const profilesDir = getProfilesDir();
   mkdirSync5(profilesDir, { recursive: true });
-  writeFileSync2(getFlatProfilePath(profile), JSON.stringify(config, null, 2) + `
+  writeFileSync4(getFlatProfilePath(profile), JSON.stringify(config, null, 2) + `
 `);
 }
 function profileExists(profile) {
   if (profile === "default") {
     return true;
   }
-  return existsSync6(getFlatProfilePath(profile)) || existsSync6(join7(getProfilesDir(), profile));
+  return getFlatProfileReadPaths(profile).some((path) => existsSync7(path)) || getConfigReadDirs().some((dir) => existsSync7(join9(dir, "profiles", profile)));
 }
-function listProfiles() {
-  const profilesDir = getProfilesDir();
+function listProfiles3() {
   const seen = new Set(["default"]);
-  if (!existsSync6(profilesDir)) {
-    return [...seen];
-  }
-  try {
-    for (const entry of readdirSync5(profilesDir)) {
-      const fullPath = join7(profilesDir, entry);
-      const stat = statSync2(fullPath);
-      if (stat.isDirectory()) {
-        seen.add(entry);
-      } else if (entry.endsWith(".json")) {
-        seen.add(entry.replace(/\.json$/, ""));
+  for (const configDir of getConfigReadDirs()) {
+    const profilesDir = join9(configDir, "profiles");
+    if (!existsSync7(profilesDir))
+      continue;
+    try {
+      for (const entry of readdirSync6(profilesDir)) {
+        const fullPath = join9(profilesDir, entry);
+        const stat = statSync3(fullPath);
+        if (stat.isDirectory()) {
+          seen.add(entry);
+        } else if (entry.endsWith(".json")) {
+          seen.add(entry.replace(/\.json$/, ""));
+        }
       }
-    }
-  } catch {}
+    } catch {}
+  }
   return [...seen].sort();
 }
 function createProfile(profile, config = {}) {
@@ -14885,11 +15770,11 @@ function createProfile(profile, config = {}) {
 }
 function clearProfile(profile = getCurrentProfile()) {
   const flatPath = getFlatProfilePath(profile);
-  const directoryPath = join7(getProfilesDir(), profile);
-  if (existsSync6(flatPath)) {
+  const directoryPath = join9(getProfilesDir(), profile);
+  if (existsSync7(flatPath)) {
     rmSync(flatPath);
   }
-  if (existsSync6(directoryPath)) {
+  if (existsSync7(directoryPath)) {
     rmSync(directoryPath, { recursive: true, force: true });
   }
 }
@@ -15185,7 +16070,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: {
@@ -15299,7 +16184,7 @@ async function runProfileCommand2(args, context) {
   switch (subcommand) {
     case "list": {
       const current = getCurrentProfile();
-      const profiles = listProfiles();
+      const profiles = listProfiles3();
       return successOutput({ current, profiles }, context.format, () => profiles.map((profile) => `${profile}${profile === current ? " (active)" : ""}`).join(`
 `));
     }
@@ -15473,7 +16358,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),
@@ -15631,7 +16516,7 @@ var imessageConnector = defineConnector({
       summary: "Reply to an existing conversation through the bridge",
       inputSchema: messageReplyInputSchema,
       async execute({ context }, input) {
-        return replyToMessage(context, input);
+        return replyToMessage2(context, input);
       }
     }
   },
@@ -15694,19 +16579,19 @@ var imessageConnector = defineConnector({
 });
 
 // src/core/connectors/stripe.ts
-import { existsSync as existsSync7 } from "fs";
-import { dirname as dirname4, join as join8 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { dirname as dirname4, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
 var __dirname3 = dirname4(fileURLToPath2(import.meta.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")
+    join10(__dirname3, "..", "..", "..", "connectors", "stripe"),
+    join10(__dirname3, "..", "..", "connectors", "stripe"),
+    join10(__dirname3, "..", "connectors", "stripe"),
+    join10(process.cwd(), "connectors", "stripe")
   ];
   for (const candidate of candidates) {
-    if (existsSync7(candidate)) {
+    if (existsSync8(candidate)) {
       return candidate;
     }
   }
@@ -15945,10 +16830,10 @@ function buildCommandHelp2(spec) {
 var ROOT_HELP3 = buildRootHelp2(COMMAND_SPECS2);
 var COMMAND_HELP3 = Object.fromEntries(COMMAND_SPECS2.map((spec) => [spec.name, buildCommandHelp2(spec)]));
 async function loadStripeApiModule() {
-  return await import(pathToFileURL2(join8(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
+  return await import(pathToFileURL2(join10(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(join10(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
 }
 function extractGlobalArgs3(args) {
   const remaining = [];
@@ -16560,7 +17445,9 @@ var stripeConnector = defineConnector({
 
 // src/core/builtins.ts
 var INTERNAL_CONNECTOR_DEFINITIONS = [
+  gmailConnector,
   githubConnector,
+  googleDriveConnector,
   imessageConnector,
   stripeConnector
 ];
@@ -22834,7 +23721,10 @@ function searchConnectors(query, context) {
   return results.slice(0, limit);
 }
 function getConnector(name) {
-  return CONNECTORS.find((c) => c.name === name);
+  if (!isValidConnectorName(name))
+    return;
+  const normalizedName = normalizeConnectorName(name);
+  return CONNECTORS.find((c) => c.name === normalizedName);
 }
 var versionsLoaded = false;
 function loadConnectorVersions() {
@@ -22843,17 +23733,17 @@ function loadConnectorVersions() {
   versionsLoaded = true;
   const thisDir = dirname5(fileURLToPath3(import.meta.url));
   const candidates = [
-    join9(thisDir, "..", "connectors"),
-    join9(thisDir, "..", "..", "connectors")
+    join11(thisDir, "..", "connectors"),
+    join11(thisDir, "..", "..", "connectors")
   ];
-  const connectorsDir = candidates.find((d) => existsSync8(d));
+  const connectorsDir = candidates.find((d) => existsSync9(d));
   if (!connectorsDir)
     return;
   for (const connector of CONNECTORS) {
     try {
-      const pkgPath = join9(connectorsDir, `connect-${connector.name}`, "package.json");
-      if (existsSync8(pkgPath)) {
-        const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+      const pkgPath = join11(getConnectorPackagePath(connectorsDir, connector.name), "package.json");
+      if (existsSync9(pkgPath)) {
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         connector.version = pkg.version || "0.0.0";
         continue;
       }
@@ -22865,16 +23755,16 @@ function loadConnectorVersions() {
   }
 }
 // src/lib/installer.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync3, readdirSync as readdirSync6, statSync as statSync3, rmSync as rmSync2 } from "fs";
-import { join as join10, dirname as dirname6 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, readdirSync as readdirSync7, statSync as statSync4, rmSync as rmSync2 } from "fs";
+import { join as join12, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __dirname4 = dirname6(fileURLToPath4(import.meta.url));
 function resolveConnectorsDir() {
-  const fromBin = join10(__dirname4, "..", "connectors");
-  if (existsSync9(fromBin))
+  const fromBin = join12(__dirname4, "..", "connectors");
+  if (existsSync10(fromBin))
     return fromBin;
-  const fromSrc = join10(__dirname4, "..", "..", "connectors");
-  if (existsSync9(fromSrc))
+  const fromSrc = join12(__dirname4, "..", "..", "connectors");
+  if (existsSync10(fromSrc))
     return fromSrc;
   return fromBin;
 }
@@ -22882,25 +23772,22 @@ var CONNECTORS_DIR = resolveConnectorsDir();
 var PROJECT_CONNECTORS_DIRNAME = ".connectors";
 var ENABLEMENT_MANIFEST_FILENAME = "manifest.json";
 var ENABLEMENT_INDEX_FILENAME = "index.ts";
-function normalizeConnectorName(name) {
-  return name.startsWith("connect-") ? name.slice("connect-".length) : name;
-}
 function getProjectConnectorsDir(targetDir) {
-  return join10(targetDir, PROJECT_CONNECTORS_DIRNAME);
+  return join12(targetDir, PROJECT_CONNECTORS_DIRNAME);
 }
 function getEnablementManifestPath(targetDir) {
-  return join10(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
+  return join12(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
 }
 function getLegacyInstallPath(targetDir, name) {
-  return join10(getProjectConnectorsDir(targetDir), `connect-${normalizeConnectorName(name)}`);
+  return join12(getProjectConnectorsDir(targetDir), legacyConnectorName(name));
 }
 function loadEnablementManifest(targetDir) {
   const manifestPath = getEnablementManifestPath(targetDir);
-  if (!existsSync9(manifestPath)) {
+  if (!existsSync10(manifestPath)) {
     return null;
   }
   try {
-    const raw = JSON.parse(readFileSync4(manifestPath, "utf-8"));
+    const raw = JSON.parse(readFileSync6(manifestPath, "utf-8"));
     if (!Array.isArray(raw.connectors)) {
       return null;
     }
@@ -22916,12 +23803,12 @@ function loadEnablementManifest(targetDir) {
 }
 function getLegacyInstalledConnectors(targetDir) {
   const connectorsDir = getProjectConnectorsDir(targetDir);
-  if (!existsSync9(connectorsDir)) {
+  if (!existsSync10(connectorsDir)) {
     return [];
   }
-  return readdirSync6(connectorsDir).filter((entry) => {
-    const fullPath = join10(connectorsDir, entry);
-    return entry.startsWith("connect-") && statSync3(fullPath).isDirectory();
+  return readdirSync7(connectorsDir).filter((entry) => {
+    const fullPath = join12(connectorsDir, entry);
+    return entry.startsWith("connect-") && statSync4(fullPath).isDirectory();
   }).map((entry) => entry.replace("connect-", "")).sort();
 }
 function getEnabledConnectors(targetDir) {
@@ -22929,7 +23816,7 @@ function getEnabledConnectors(targetDir) {
   return [...new Set([...manifestConnectors, ...getLegacyInstalledConnectors(targetDir)])].sort();
 }
 function updateConnectorsIndex(connectorsDir, connectors18) {
-  const indexPath = join10(connectorsDir, ENABLEMENT_INDEX_FILENAME);
+  const indexPath = join12(connectorsDir, ENABLEMENT_INDEX_FILENAME);
   const connectorList = connectors18.map((connector) => `  "${connector}",`).join(`
 `);
   const content = `/**
@@ -22945,7 +23832,7 @@ ${connectorList}
 
 export type EnabledConnectorName = typeof enabledConnectors[number];
 `;
-  writeFileSync3(indexPath, content);
+  writeFileSync5(indexPath, content);
 }
 function writeEnablementManifest(targetDir, connectors18) {
   const connectorsDir = getProjectConnectorsDir(targetDir);
@@ -22956,17 +23843,16 @@ function writeEnablementManifest(targetDir, connectors18) {
     updatedAt: new Date().toISOString(),
     connectors: [...new Set(connectors18.map((value) => normalizeConnectorName(value)))].sort()
   };
-  writeFileSync3(getEnablementManifestPath(targetDir), JSON.stringify(manifest, null, 2) + `
+  writeFileSync5(getEnablementManifestPath(targetDir), JSON.stringify(manifest, null, 2) + `
 `);
   updateConnectorsIndex(connectorsDir, manifest.connectors);
 }
 function getConnectorPath(name) {
-  const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  return join10(CONNECTORS_DIR, connectorName);
+  return getConnectorPackagePath(CONNECTORS_DIR, name);
 }
 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;
@@ -22999,7 +23885,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 {
@@ -23034,9 +23920,9 @@ function parseConnectorDocs(raw) {
 function getConnectorDocs(name) {
   const normalizedName = normalizeConnectorName(name);
   const connectorPath = getConnectorPath(normalizedName);
-  const claudeMdPath = join10(connectorPath, "CLAUDE.md");
-  if (existsSync9(claudeMdPath)) {
-    return parseConnectorDocs(readFileSync4(claudeMdPath, "utf-8"));
+  const claudeMdPath = join12(connectorPath, "CLAUDE.md");
+  if (existsSync10(claudeMdPath)) {
+    return parseConnectorDocs(readFileSync6(claudeMdPath, "utf-8"));
   }
   const internalDocs = getInternalConnectorDefinition(normalizedName)?.docsMarkdown;
   if (internalDocs) {
@@ -23080,23 +23966,171 @@ 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;
 }
 // src/lib/runner.ts
-import { existsSync as existsSync10, readdirSync as readdirSync7 } from "fs";
-import { join as join11, dirname as dirname7 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync9 } from "fs";
+import { join as join14, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { spawn } from "child_process";
+
+// src/server/auth.ts
+import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync7, readdirSync as readdirSync8, rmSync as rmSync3, statSync as statSync5 } from "fs";
+import { join as join13 } from "path";
+var oauthStateStore = new Map;
+var GOOGLE_SCOPES = {
+  gmail: [
+    "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://mail.google.com/"
+  ].join(" "),
+  googlecalendar: [
+    "https://www.googleapis.com/auth/calendar",
+    "https://www.googleapis.com/auth/calendar.events"
+  ].join(" "),
+  googledrive: [
+    "https://www.googleapis.com/auth/drive",
+    "https://www.googleapis.com/auth/drive.file"
+  ].join(" "),
+  googledocs: [
+    "https://www.googleapis.com/auth/documents",
+    "https://www.googleapis.com/auth/drive.file"
+  ].join(" "),
+  googlesheets: [
+    "https://www.googleapis.com/auth/spreadsheets",
+    "https://www.googleapis.com/auth/drive.file"
+  ].join(" "),
+  googletasks: [
+    "https://www.googleapis.com/auth/tasks"
+  ].join(" "),
+  googlecontacts: [
+    "https://www.googleapis.com/auth/contacts",
+    "https://www.googleapis.com/auth/contacts.readonly"
+  ].join(" "),
+  google: [
+    "openid",
+    "https://www.googleapis.com/auth/userinfo.email",
+    "https://www.googleapis.com/auth/userinfo.profile"
+  ].join(" ")
+};
+function getAuthType(name) {
+  name = normalizeConnectorName(name);
+  const docs = getConnectorDocs(name);
+  if (!docs?.auth)
+    return "apikey";
+  const authLower = docs.auth.toLowerCase();
+  if (authLower.includes("oauth"))
+    return "oauth";
+  if (authLower.includes("bearer token"))
+    return "bearer";
+  return "apikey";
+}
+function getConnectorConfigReadDirs2(name) {
+  name = normalizeConnectorName(name);
+  return getConnectorConfigReadDirs(name);
+}
+function getCurrentProfile2(name) {
+  name = normalizeConnectorName(name);
+  for (const configDir of getConnectorConfigReadDirs2(name)) {
+    const currentProfileFile = join13(configDir, "current_profile");
+    if (existsSync11(currentProfileFile)) {
+      try {
+        return readFileSync7(currentProfileFile, "utf-8").trim() || "default";
+      } catch {
+        return "default";
+      }
+    }
+  }
+  return "default";
+}
+function loadProfileConfigFromDir(configDir, profile) {
+  let flatConfig = {};
+  let dirConfig = {};
+  const profileFile = join13(configDir, "profiles", `${profile}.json`);
+  if (existsSync11(profileFile)) {
+    try {
+      flatConfig = JSON.parse(readFileSync7(profileFile, "utf-8"));
+    } catch {}
+  }
+  const profileDirConfig = join13(configDir, "profiles", profile, "config.json");
+  if (existsSync11(profileDirConfig)) {
+    try {
+      dirConfig = JSON.parse(readFileSync7(profileDirConfig, "utf-8"));
+    } catch {}
+  }
+  return { ...flatConfig, ...dirConfig };
+}
+function loadProfileConfig(name) {
+  name = normalizeConnectorName(name);
+  const profile = getCurrentProfile2(name);
+  const merged = {};
+  for (const configDir of [...getConnectorConfigReadDirs2(name)].reverse()) {
+    Object.assign(merged, loadProfileConfigFromDir(configDir, profile));
+  }
+  return merged;
+}
+function loadTokens3(name) {
+  name = normalizeConnectorName(name);
+  const profile = getCurrentProfile2(name);
+  for (const configDir of getConnectorConfigReadDirs2(name)) {
+    const tokensFile = join13(configDir, "profiles", profile, "tokens.json");
+    if (existsSync11(tokensFile)) {
+      try {
+        return JSON.parse(readFileSync7(tokensFile, "utf-8"));
+      } catch {
+        return null;
+      }
+    }
+  }
+  const profileConfig = loadProfileConfig(name);
+  if (profileConfig.refreshToken || profileConfig.accessToken) {
+    return {
+      accessToken: profileConfig.accessToken ?? "",
+      refreshToken: profileConfig.refreshToken,
+      expiresAt: profileConfig.expiresAt ?? 0,
+      tokenType: profileConfig.tokenType,
+      scope: profileConfig.scope
+    };
+  }
+  return null;
+}
+function getEnvVars(name) {
+  name = normalizeConnectorName(name);
+  const docs = getConnectorDocs(name);
+  return docs?.envVars || [];
+}
+function getOAuthConfig(name) {
+  name = normalizeConnectorName(name);
+  for (const configDir of getConnectorConfigReadDirs2(name)) {
+    const credentialsFile = join13(configDir, "credentials.json");
+    if (existsSync11(credentialsFile)) {
+      try {
+        const creds = JSON.parse(readFileSync7(credentialsFile, "utf-8"));
+        return { clientId: creds.clientId, clientSecret: creds.clientSecret };
+      } catch {}
+    }
+  }
+  const config = loadProfileConfig(name);
+  return {
+    clientId: config.clientId,
+    clientSecret: config.clientSecret
+  };
+}
+
+// src/lib/runner.ts
 var __dirname5 = dirname7(fileURLToPath5(import.meta.url));
 function resolveConnectorsDir2() {
-  const fromBin = join11(__dirname5, "..", "connectors");
-  if (existsSync10(fromBin))
+  const fromBin = join14(__dirname5, "..", "connectors");
+  if (existsSync12(fromBin))
     return fromBin;
-  const fromSrc = join11(__dirname5, "..", "..", "connectors");
-  if (existsSync10(fromSrc))
+  const fromSrc = join14(__dirname5, "..", "..", "connectors");
+  if (existsSync12(fromSrc))
     return fromSrc;
   return fromBin;
 }
@@ -23125,8 +24159,9 @@ var ENV_VAR_NAME_OVERRIDES = {
 };
 function buildEnvWithCredentials(connectorName, baseEnv) {
   const env = { ...baseEnv };
-  const prefixes = ENV_VAR_NAME_OVERRIDES[connectorName] || [
-    connectorName.toUpperCase().replace(/-/g, "_")
+  const normalizedConnectorName = normalizeConnectorName(connectorName);
+  const prefixes = ENV_VAR_NAME_OVERRIDES[normalizedConnectorName] || [
+    normalizedConnectorName.toUpperCase().replace(/-/g, "_")
   ];
   for (const prefix of prefixes) {
     const canonicalKey = `${prefix}_API_KEY`;
@@ -23147,13 +24182,32 @@ function buildEnvWithCredentials(connectorName, baseEnv) {
       }
     }
   }
+  if (getAuthType(normalizedConnectorName) === "oauth") {
+    const oauthConfig = getOAuthConfig(normalizedConnectorName);
+    const tokens = loadTokens3(normalizedConnectorName);
+    for (const { variable } of getEnvVars(normalizedConnectorName)) {
+      if (env[variable])
+        continue;
+      if (variable.endsWith("_CLIENT_ID") && oauthConfig.clientId) {
+        env[variable] = oauthConfig.clientId;
+      } else if (variable.endsWith("_CLIENT_SECRET") && oauthConfig.clientSecret) {
+        env[variable] = oauthConfig.clientSecret;
+      } else if (variable.endsWith("_ACCESS_TOKEN") && tokens?.accessToken) {
+        env[variable] = tokens.accessToken;
+      } else if (variable.endsWith("_REFRESH_TOKEN") && tokens?.refreshToken) {
+        env[variable] = tokens.refreshToken;
+      } else if (variable.endsWith("_TOKEN_EXPIRES_AT") && tokens?.expiresAt) {
+        env[variable] = String(tokens.expiresAt);
+      }
+    }
+  }
   return env;
 }
 function getConnectorCliPath(name) {
-  const safeName = name.replace(/[^a-z0-9-]/g, "");
-  const connectorDir = join11(CONNECTORS_DIR2, `connect-${safeName}`);
-  const cliPath = join11(connectorDir, "src", "cli", "index.ts");
-  if (existsSync10(cliPath))
+  const safeName = normalizeConnectorName(name).replace(/[^a-z0-9-]/g, "");
+  const connectorDir = getConnectorPackagePath(CONNECTORS_DIR2, safeName);
+  const cliPath = join14(connectorDir, "src", "cli", "index.ts");
+  if (existsSync12(cliPath))
     return cliPath;
   return null;
 }
@@ -23191,7 +24245,7 @@ function parseCommanderHelpOperations(helpText) {
         inCommands = false;
       continue;
     }
-    const row = line.match(/^ {2}(\S.*?)(?: {2,}(.+))?$/);
+    const row = line.match(/^ {2}(?! )(\S.*?)(?: {2,}(.+))?$/);
     if (!row)
       continue;
     const usage = row[1].trim();
@@ -23208,8 +24262,9 @@ function parseCommanderHelpOperations(helpText) {
   return operations;
 }
 function runConnectorCommand(name, args, timeoutMs = 30000) {
+  const connectorName = normalizeConnectorName(name);
   getConnectorsHome();
-  const internalRuntime = getInternalCommandRuntime(name);
+  const internalRuntime = getInternalCommandRuntime(connectorName);
   if (internalRuntime?.run) {
     return Promise.resolve(internalRuntime.run(args)).then((result) => {
       if (result) {
@@ -23223,17 +24278,125 @@ function runConnectorCommand(name, args, timeoutMs = 30000) {
           success: result.success ?? exitCode === 0
         };
       }
-      return runLegacyConnectorCommand(name, args, timeoutMs);
+      return runLegacyConnectorCommand(connectorName, args, timeoutMs);
     });
   }
-  return runLegacyConnectorCommand(name, args, timeoutMs);
+  return runLegacyConnectorCommand(connectorName, args, timeoutMs);
+}
+async function runConnectorOperation(args) {
+  const connectorName = normalizeConnectorName(args.connector);
+  const internal = getInternalConnectorDefinition(connectorName);
+  if (internal?.operations[args.operation]) {
+    try {
+      const operationData = await executeConnectorOperation(internal, {
+        operation: args.operation,
+        input: args.input,
+        profile: args.profile
+      });
+      const commandResult = normalizeOperationReturn(operationData);
+      return {
+        connector: connectorName,
+        operation: args.operation,
+        profile: args.profile,
+        ...commandResult
+      };
+    } catch (error) {
+      return {
+        connector: connectorName,
+        operation: args.operation,
+        profile: args.profile,
+        stdout: "",
+        stderr: error.message,
+        exitCode: 1,
+        success: false
+      };
+    }
+  }
+  const commandArgs = buildConnectorOperationArgs(args);
+  const result = await runConnectorCommand(connectorName, commandArgs, args.timeoutMs ?? 30000);
+  const response = {
+    ...result,
+    connector: connectorName,
+    operation: args.operation,
+    profile: args.profile
+  };
+  if (args.parseJson !== false && result.stdout) {
+    try {
+      response.data = JSON.parse(result.stdout);
+    } catch {}
+  }
+  return response;
+}
+function normalizeOperationReturn(value) {
+  if (isRunResult(value)) {
+    const result = value;
+    const response = {
+      ...result
+    };
+    if (result.stdout) {
+      try {
+        response.data = JSON.parse(result.stdout);
+      } catch {}
+    }
+    return response;
+  }
+  return {
+    data: value,
+    stdout: JSON.stringify(value),
+    stderr: "",
+    exitCode: 0,
+    success: true
+  };
+}
+function isRunResult(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  return typeof candidate.stdout === "string" && typeof candidate.stderr === "string" && typeof candidate.exitCode === "number" && typeof candidate.success === "boolean";
+}
+function buildConnectorOperationArgs(args) {
+  const commandArgs = [];
+  if (args.profile) {
+    commandArgs.push("--profile", args.profile);
+  }
+  commandArgs.push(...args.operation.split(".").filter(Boolean));
+  for (const positional of args.input?.args ?? []) {
+    commandArgs.push(String(positional));
+  }
+  let hasFormat = false;
+  for (const [key, value] of Object.entries(args.input ?? {})) {
+    if (key === "args")
+      continue;
+    if (value === undefined || value === null)
+      continue;
+    const flag = `--${key.replace(/_/g, "-").replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)}`;
+    if (flag === "--format" || flag === "--json")
+      hasFormat = true;
+    if (typeof value === "boolean") {
+      if (value)
+        commandArgs.push(flag);
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        commandArgs.push(flag, String(item));
+      }
+      continue;
+    }
+    commandArgs.push(flag, String(value));
+  }
+  if (args.parseJson !== false && !hasFormat) {
+    commandArgs.push("--format", "json");
+  }
+  return commandArgs;
 }
 function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
-  const cliPath = getConnectorCliPath(name);
+  const connectorName = normalizeConnectorName(name);
+  const cliPath = getConnectorCliPath(connectorName);
   if (!cliPath) {
     return Promise.resolve({
       stdout: "",
-      stderr: `Connector '${name}' not found or has no CLI.`,
+      stderr: `Connector '${connectorName}' not found or has no CLI.`,
       exitCode: 1,
       success: false
     });
@@ -23241,7 +24404,7 @@ function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
   return new Promise((resolve) => {
     const proc = spawn("bun", ["run", cliPath, ...args], {
       timeout: timeoutMs,
-      env: buildEnvWithCredentials(name, process.env),
+      env: buildEnvWithCredentials(connectorName, process.env),
       stdio: ["pipe", "pipe", "pipe"]
     });
     let stdout = "";
@@ -23271,7 +24434,8 @@ function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
   });
 }
 async function getConnectorOperations(name) {
-  const internalRuntime = getInternalCommandRuntime(name);
+  const connectorName = normalizeConnectorName(name);
+  const internalRuntime = getInternalCommandRuntime(connectorName);
   if (internalRuntime?.commands.length) {
     const operations2 = internalRuntime.commands.map((command) => ({
       name: command.name,
@@ -23283,15 +24447,15 @@ async function getConnectorOperations(name) {
     return {
       commands: operations2.map((operation) => operation.name),
       operations: operations2,
-      helpText: internalRuntime.helpText ?? buildInternalHelpText(name, internalRuntime.commands),
+      helpText: internalRuntime.helpText ?? buildInternalHelpText(connectorName, internalRuntime.commands),
       hasCli: true
     };
   }
-  const cliPath = getConnectorCliPath(name);
+  const cliPath = getConnectorCliPath(connectorName);
   if (!cliPath) {
     return { commands: [], operations: [], helpText: "", hasCli: false };
   }
-  const result = await runConnectorCommand(name, ["--help"]);
+  const result = await runConnectorCommand(connectorName, ["--help"]);
   const helpText = result.stdout || result.stderr;
   const operations = parseCommanderHelpOperations(helpText);
   return {
@@ -23302,7 +24466,8 @@ async function getConnectorOperations(name) {
   };
 }
 async function getConnectorCommandHelp(name, command) {
-  const internalRuntime = getInternalCommandRuntime(name);
+  const connectorName = normalizeConnectorName(name);
+  const internalRuntime = getInternalCommandRuntime(connectorName);
   if (internalRuntime?.getHelp) {
     const help = await internalRuntime.getHelp(command);
     if (help) {
@@ -23313,17 +24478,15 @@ async function getConnectorCommandHelp(name, command) {
   if (runtimeCommand?.helpText) {
     return runtimeCommand.helpText;
   }
-  const result = await runConnectorCommand(name, [command, "--help"]);
+  const result = await runConnectorCommand(connectorName, [command, "--help"]);
   return result.stdout || result.stderr;
 }
 function getConnectorsWithCli() {
   const connectors18 = new Set;
   try {
-    const dirs = readdirSync7(CONNECTORS_DIR2);
+    const dirs = readdirSync9(CONNECTORS_DIR2);
     for (const dir of dirs) {
-      if (!dir.startsWith("connect-"))
-        continue;
-      const name = dir.replace("connect-", "");
+      const name = normalizeConnectorName(dir);
       if (getConnectorCliPath(name)) {
         connectors18.add(name);
       }
@@ -23336,8 +24499,74 @@ function getConnectorsWithCli() {
   }
   return [...connectors18].sort();
 }
+// src/lib/manifest.ts
+function buildAliases(name) {
+  const canonicalName = normalizeConnectorName(name);
+  const legacyName = legacyConnectorName(canonicalName);
+  return canonicalName === legacyName ? [canonicalName] : [canonicalName, legacyName];
+}
+async function loadOperations(name, includeOperations) {
+  if (!includeOperations || !hasConnectorCommandSurface(name))
+    return;
+  return (await getConnectorOperations(name)).operations;
+}
+async function getConnectorCapability(name, options = {}) {
+  const connectorName = normalizeConnectorName(name);
+  const meta = getConnector(connectorName);
+  if (!meta)
+    return null;
+  const docs = getConnectorDocs(connectorName);
+  const configPaths = resolveConnectorConfigPaths(connectorName);
+  const operations = await loadOperations(connectorName, options.includeOperations);
+  return {
+    ...meta,
+    id: connectorName,
+    aliases: buildAliases(connectorName),
+    runtime: {
+      packageName: "@hasna/connectors",
+      connectorId: connectorName,
+      legacyConnectorId: legacyConnectorName(connectorName),
+      packagePath: getConnectorPath(connectorName),
+      configDirName: configPaths.preferredDirName,
+      legacyConfigDirName: configPaths.legacyName,
+      internal: Boolean(getInternalConnectorDefinition(connectorName)),
+      packageDirectory: connectorExists(connectorName),
+      commandSurface: hasConnectorCommandSurface(connectorName)
+    },
+    auth: {
+      type: getAuthType(connectorName),
+      summary: docs?.auth ?? null,
+      envVars: docs?.envVars ?? []
+    },
+    docs: {
+      overview: docs?.overview ?? "",
+      cliCommands: docs?.cliCommands ?? "",
+      dataStorage: docs?.dataStorage ?? null
+    },
+    ...operations ? { operations } : {}
+  };
+}
+async function getConnectorCapabilityManifest(options = {}) {
+  const names = options.connectorNames ? [...new Set(options.connectorNames.map((name) => normalizeConnectorName(name)))].sort() : CONNECTORS.map((connector) => connector.name);
+  const connectors18 = [];
+  for (const name of names) {
+    const capability = await getConnectorCapability(name, options);
+    if (capability)
+      connectors18.push(capability);
+  }
+  return {
+    version: 1,
+    packageName: "@hasna/connectors",
+    packageVersion: package_default.version,
+    generatedAt: new Date().toISOString(),
+    categories: CATEGORIES,
+    connectorCount: connectors18.length,
+    connectors: connectors18
+  };
+}
 export {
   searchConnectors,
+  runConnectorOperation,
   runConnectorCommand,
   removeConnector,
   loadConnectorVersions,
@@ -23354,10 +24583,13 @@ export {
   getConnectorDocs,
   getConnectorCommandHelp,
   getConnectorCliPath,
+  getConnectorCapabilityManifest,
+  getConnectorCapability,
   getConnector,
   executeConnectorOperation,
   defineConnector,
   connectorExists,
+  buildConnectorOperationArgs,
   ConnectorOperationNotFoundError,
   ConnectorDefinitionError,
   CONNECTORS,