@hasna/connectors 1.3.25 → 1.3.27

package/bin/index.js

@@ -1909,7 +1909,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/connectors",
-    version: "1.3.25",
+    version: "1.3.27",
     description: "Open source connector library - Install API connectors with a single command",
     type: "module",
     bin: {
@@ -1997,7 +1997,7 @@ var init_package = __esm(() => {
 });
 
 // src/core/errors.ts
-var ConnectorDefinitionError;
+var ConnectorDefinitionError, ConnectorOperationNotFoundError;
 var init_errors = __esm(() => {
   ConnectorDefinitionError = class ConnectorDefinitionError extends Error {
     code;
@@ -2007,6 +2007,16 @@ var init_errors = __esm(() => {
       this.code = code;
     }
   };
+  ConnectorOperationNotFoundError = class ConnectorOperationNotFoundError extends Error {
+    connectorName;
+    operationName;
+    constructor(connectorName, operationName) {
+      super(`Operation '${operationName}' not found on connector '${connectorName}'`);
+      this.name = "ConnectorOperationNotFoundError";
+      this.connectorName = connectorName;
+      this.operationName = operationName;
+    }
+  };
 });
 
 // src/core/connector.ts
@@ -2048,11 +2058,34 @@ function defineConnector(definition) {
     operations: normalizedOperations
   };
 }
+function listConnectorOperations(connector) {
+  return Object.values(connector.operations).sort((a, b) => a.name.localeCompare(b.name));
+}
+function getConnectorOperation(connector, name) {
+  return listConnectorOperations(connector).find((operation) => operation.name === name);
+}
+async function executeConnectorOperation(connector, args) {
+  const operation = getConnectorOperation(connector, args.operation);
+  if (!operation) {
+    throw new ConnectorOperationNotFoundError(connector.meta.name, args.operation);
+  }
+  const context = connector.createContext ? await connector.createContext({
+    credentials: args.credentials,
+    profile: args.profile
+  }) : undefined;
+  const parsedInput = operation.inputSchema ? operation.inputSchema.parse(args.input ?? {}) : args.input ?? {};
+  return operation.execute({
+    connector,
+    context,
+    profile: args.profile,
+    credentials: args.credentials
+  }, parsedInput);
+}
 var CONNECTOR_NAME_RE, OPERATION_NAME_RE;
 var init_connector = __esm(() => {
   init_errors();
   CONNECTOR_NAME_RE = /^[a-z0-9-]+$/;
-  OPERATION_NAME_RE = /^[a-z0-9:._-]+$/;
+  OPERATION_NAME_RE = /^[A-Za-z0-9:._-]+$/;
 });
 
 // src/core/registry.ts
@@ -6054,10 +6087,10 @@ import { dirname, join } from "path";
 import { fileURLToPath, pathToFileURL } from "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)) {
@@ -6913,38 +6946,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 modifyMessage(profile, messageId, addLabelIds, removeLabelIds) {
+  return requestJson(profile, `/users/me/messages/${encodeURIComponent(messageId)}/modify`, {}, {
+    method: "POST",
+    body: {
+      addLabelIds: addLabelIds ?? [],
+      removeLabelIds: removeLabelIds ?? []
+    }
+  });
 }
-async function requestBinary(profile, path, params) {
-  return (await request(profile, path, params)).arrayBuffer();
+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 request(profile, path, params) {
+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(`${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 error = data;
+    throw new Error(`Gmail request failed (${response.status}): ${error.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;
@@ -6955,9 +7050,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" },
@@ -6970,7 +7065,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,
@@ -6997,8 +7092,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()) {
@@ -7029,11 +7124,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, "gmail"), join2(baseDir, "connect-gmail")];
 }
 function readJson(path) {
   if (!existsSync2(path))
@@ -7044,6 +7139,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, "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;
@@ -7068,11 +7535,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",
@@ -7153,12 +7620,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,
@@ -7173,7 +7640,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
         })
@@ -7182,7 +7649,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";
@@ -7196,7 +7663,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
@@ -7279,27 +7746,27 @@ __export(exports_dist, {
 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 } from "os";
-import { existsSync as existsSync4, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
-import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
+import { join as join42 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync32 } from "fs";
 import { join as join5 } from "path";
 import { join as join6, dirname as dirname2 } from "path";
-import { existsSync as existsSync6, writeFileSync as writeFileSync22, unlinkSync, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync6, writeFileSync as writeFileSync22, unlinkSync, mkdirSync as mkdirSync32 } from "fs";
 import { homedir as homedir5, platform } from "os";
 function __accessProp2(key) {
   return this[key];
@@ -8182,33 +8649,33 @@ function custom2(check, _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 migrateDotfile(serviceName) {
-  const legacyDir = join3(homedir2(), `.${serviceName}`);
-  const newDir = join3(HASNA_DIR, serviceName);
-  if (!existsSync3(legacyDir))
+  const legacyDir = join4(homedir3(), `.${serviceName}`);
+  const newDir = join4(HASNA_DIR, serviceName);
+  if (!existsSync4(legacyDir))
     return [];
-  if (existsSync3(newDir))
+  if (existsSync4(newDir))
     return [];
-  mkdirSync2(newDir, { recursive: true });
+  mkdirSync3(newDir, { recursive: true });
   const migrated = [];
   copyDirRecursive(legacyDir, newDir, legacyDir, migrated);
   return migrated;
 }
 function copyDirRecursive(src, dest, root, migrated) {
-  const entries = readdirSync2(src, { withFileTypes: true });
+  const entries = readdirSync3(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join3(src, entry.name);
-    const destPath = join3(dest, entry.name);
+    const srcPath = join4(src, entry.name);
+    const destPath = join4(dest, entry.name);
     if (entry.isDirectory()) {
-      mkdirSync2(destPath, { recursive: true });
+      mkdirSync3(destPath, { recursive: true });
       copyDirRecursive(srcPath, destPath, root, migrated);
     } else {
       copyFileSync(srcPath, destPath);
@@ -8217,10 +8684,10 @@ function copyDirRecursive(src, dest, root, migrated) {
   }
 }
 function hasLegacyDotfile(serviceName) {
-  return existsSync3(join3(homedir2(), `.${serviceName}`));
+  return existsSync4(join4(homedir3(), `.${serviceName}`));
 }
 function getHasnaDir() {
-  mkdirSync2(HASNA_DIR, { recursive: true });
+  mkdirSync3(HASNA_DIR, { recursive: true });
   return HASNA_DIR;
 }
 function getConfigDir() {
@@ -8234,7 +8701,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({});
@@ -8242,7 +8709,7 @@ function getCloudConfig() {
 }
 function saveCloudConfig(config) {
   mkdirSync22(CONFIG_DIR, { recursive: true });
-  writeFileSync2(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+  writeFileSync3(CONFIG_PATH, JSON.stringify(config, null, 2) + `
 `, "utf-8");
 }
 function getConnectionString(dbName) {
@@ -8272,7 +8739,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 {
@@ -8294,7 +8761,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 = [
@@ -9230,7 +9697,7 @@ function resetAllSyncMeta(db) {
 }
 function getAutoSyncConfig() {
   try {
-    if (!existsSync4(AUTO_SYNC_CONFIG_PATH)) {
+    if (!existsSync42(AUTO_SYNC_CONFIG_PATH)) {
       return { ...DEFAULT_AUTO_SYNC_CONFIG };
     }
     const raw = JSON.parse(readFileSync22(AUTO_SYNC_CONFIG_PATH, "utf-8"));
@@ -9348,7 +9815,7 @@ function discoverSyncableServices2() {
   const hasnaDir = getHasnaDir();
   const services = [];
   try {
-    const entries = readdirSync3(hasnaDir, { withFileTypes: true });
+    const entries = readdirSync32(hasnaDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
@@ -9518,7 +9985,7 @@ function createLaunchdPlist(intervalMinutes) {
 async function registerLaunchd(intervalMinutes) {
   const plistPath = getLaunchdPlistPath();
   const plistDir = dirname2(plistPath);
-  mkdirSync3(plistDir, { recursive: true });
+  mkdirSync32(plistDir, { recursive: true });
   try {
     await Bun.spawn(["launchctl", "unload", plistPath]).exited;
   } catch {}
@@ -9569,7 +10036,7 @@ WantedBy=timers.target
 }
 async function registerSystemd(intervalMinutes) {
   const dir = getSystemdDir();
-  mkdirSync3(dir, { recursive: true });
+  mkdirSync32(dir, { recursive: true });
   writeFileSync22(join6(dir, `${SERVICE_NAME}.service`), createSystemdService());
   writeFileSync22(join6(dir, `${SERVICE_NAME}.timer`), createSystemdTimer(intervalMinutes));
   await Bun.spawn(["systemctl", "--user", "daemon-reload"]).exited;
@@ -9594,7 +10061,7 @@ async function registerSyncSchedule(intervalMinutes) {
   if (intervalMinutes <= 0) {
     throw new Error("Interval must be a positive number of minutes.");
   }
-  mkdirSync3(CONFIG_DIR2, { recursive: true });
+  mkdirSync32(CONFIG_DIR2, { recursive: true });
   if (platform() === "darwin") {
     await registerLaunchd(intervalMinutes);
   } else {
@@ -18168,7 +18635,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, {
@@ -18264,7 +18731,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");
   DEFAULT_AUTO_SYNC_CONFIG = {
     auto_sync_on_start: true,
     auto_sync_on_stop: true
@@ -18473,17 +18940,115 @@ var init_database = __esm(() => {
   DB_PATH = join7(DB_DIR, "connectors.db");
 });
 
+// src/lib/connector-resolver.ts
+import { existsSync as existsSync9, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
+import { join as join9 } from "path";
+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) => join9(connectorsDir, dirName));
+  const existingPath = checkedPaths.find((path) => existsSync9(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 = join9(connectorsHome, preferredDirName);
+  const legacyPath = join9(connectorsHome, resolution.legacyName);
+  const paths = preferredPath === legacyPath ? [preferredPath] : [preferredPath, legacyPath];
+  const existingPaths = paths.filter((path) => existsSync9(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;
+}
+function listConfiguredConnectorNames(connectorsHome = getConnectorsHome()) {
+  if (!existsSync9(connectorsHome))
+    return [];
+  const names = new Set;
+  for (const entry of readdirSync5(connectorsHome)) {
+    const fullPath = join9(connectorsHome, entry);
+    try {
+      if (!statSync2(fullPath).isDirectory())
+        continue;
+      if (!isValidConnectorName(entry))
+        continue;
+      names.add(normalizeConnectorName(entry));
+    } catch {}
+  }
+  return [...names].sort();
+}
+var LEGACY_CONNECTOR_PREFIX = "connect-", CONNECTOR_NAME_RE2;
+var init_connector_resolver = __esm(() => {
+  init_database();
+  CONNECTOR_NAME_RE2 = /^[a-z0-9-]+$/;
+});
+
 // src/core/connectors/imessage.ts
 import {
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync3,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync4,
   readdirSync as readdirSync6,
   rmSync,
-  statSync as statSync2,
-  writeFileSync as writeFileSync3
+  statSync as statSync3,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function buildRootHelp(specs) {
   const lines = [
     "Usage: connect-imessage [options] [command]",
@@ -18528,36 +19093,44 @@ function buildCommandHelp(spec) {
 `);
 }
 function getConfigDir2() {
-  return join9(getConnectorsHome(), CONNECTOR_DIRNAME);
+  return getConnectorConfigDir(CONNECTOR_NAME);
+}
+function getConfigReadDirs() {
+  return getConnectorConfigReadDirs(CONNECTOR_NAME);
 }
 function getProfilesDir() {
-  return join9(getConfigDir2(), "profiles");
+  return join10(getConfigDir2(), "profiles");
 }
 function getCurrentProfile() {
-  const currentProfileFile = join9(getConfigDir2(), "current_profile");
-  if (!existsSync9(currentProfileFile)) {
-    return "default";
-  }
-  try {
-    return readFileSync3(currentProfileFile, "utf-8").trim() || "default";
-  } catch {
-    return "default";
+  for (const configDir of getConfigReadDirs()) {
+    const currentProfileFile = join10(configDir, "current_profile");
+    if (!existsSync10(currentProfileFile))
+      continue;
+    try {
+      return readFileSync4(currentProfileFile, "utf-8").trim() || "default";
+    } catch {
+      return "default";
+    }
   }
+  return "default";
 }
 function setCurrentProfile(profile) {
   const configDir = getConfigDir2();
-  mkdirSync6(configDir, { recursive: true });
-  writeFileSync3(join9(configDir, "current_profile"), profile);
+  mkdirSync5(configDir, { recursive: true });
+  writeFileSync4(join10(configDir, "current_profile"), profile);
 }
 function getFlatProfilePath(profile) {
-  return join9(getProfilesDir(), `${profile}.json`);
+  return join10(getProfilesDir(), `${profile}.json`);
 }
-function getDirectoryProfilePath(profile) {
-  return join9(getProfilesDir(), profile, "config.json");
+function getFlatProfileReadPaths(profile) {
+  return getConfigReadDirs().map((dir) => join10(dir, "profiles", `${profile}.json`));
+}
+function getDirectoryProfileReadPaths(profile) {
+  return getConfigReadDirs().map((dir) => join10(dir, "profiles", profile, "config.json"));
 }
 function loadJsonFile(path) {
   try {
-    return JSON.parse(readFileSync3(path, "utf-8"));
+    return JSON.parse(readFileSync4(path, "utf-8"));
   } catch {
     return {};
   }
@@ -18573,8 +19146,8 @@ function sanitizeProfileConfig(config) {
   };
 }
 function loadProfile(profile = getCurrentProfile()) {
-  const flatConfig = existsSync9(getFlatProfilePath(profile)) ? loadJsonFile(getFlatProfilePath(profile)) : {};
-  const directoryConfig = existsSync9(getDirectoryProfilePath(profile)) ? loadJsonFile(getDirectoryProfilePath(profile)) : {};
+  const flatConfig = getFlatProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync10(path) ? loadJsonFile(path) : {} }), {});
+  const directoryConfig = getDirectoryProfileReadPaths(profile).reverse().reduce((config, path) => ({ ...config, ...existsSync10(path) ? loadJsonFile(path) : {} }), {});
   return sanitizeProfileConfig({
     ...flatConfig,
     ...directoryConfig
@@ -18582,33 +19155,34 @@ function loadProfile(profile = getCurrentProfile()) {
 }
 function writeProfile(profile, config) {
   const profilesDir = getProfilesDir();
-  mkdirSync6(profilesDir, { recursive: true });
-  writeFileSync3(getFlatProfilePath(profile), JSON.stringify(config, null, 2) + `
+  mkdirSync5(profilesDir, { recursive: true });
+  writeFileSync4(getFlatProfilePath(profile), JSON.stringify(config, null, 2) + `
 `);
 }
 function profileExists(profile) {
   if (profile === "default") {
     return true;
   }
-  return existsSync9(getFlatProfilePath(profile)) || existsSync9(join9(getProfilesDir(), profile));
+  return getFlatProfileReadPaths(profile).some((path) => existsSync10(path)) || getConfigReadDirs().some((dir) => existsSync10(join10(dir, "profiles", profile)));
 }
-function listProfiles2() {
-  const profilesDir = getProfilesDir();
+function listProfiles3() {
   const seen = new Set(["default"]);
-  if (!existsSync9(profilesDir)) {
-    return [...seen];
-  }
-  try {
-    for (const entry of readdirSync6(profilesDir)) {
-      const fullPath = join9(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 = join10(configDir, "profiles");
+    if (!existsSync10(profilesDir))
+      continue;
+    try {
+      for (const entry of readdirSync6(profilesDir)) {
+        const fullPath = join10(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 = {}) {
@@ -18621,11 +19195,11 @@ function createProfile(profile, config = {}) {
 }
 function clearProfile(profile = getCurrentProfile()) {
   const flatPath = getFlatProfilePath(profile);
-  const directoryPath = join9(getProfilesDir(), profile);
-  if (existsSync9(flatPath)) {
+  const directoryPath = join10(getProfilesDir(), profile);
+  if (existsSync10(flatPath)) {
     rmSync(flatPath);
   }
-  if (existsSync9(directoryPath)) {
+  if (existsSync10(directoryPath)) {
     rmSync(directoryPath, { recursive: true, force: true });
   }
 }
@@ -18921,7 +19495,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: {
@@ -19035,7 +19609,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(`
 `));
     }
@@ -19209,7 +19783,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),
@@ -19228,7 +19802,7 @@ function createOperationContext(args) {
     deviceId: extractCredentialString(args.credentials, "deviceId")
   });
 }
-var CONNECTOR_DIRNAME = "connect-imessage", COMMAND_SPECS, ROOT_HELP2, COMMAND_HELP2, COMMAND_DESCRIPTORS, IMESSAGE_DOCS = `# CLAUDE.md
+var CONNECTOR_NAME = "imessage", COMMAND_SPECS, ROOT_HELP2, COMMAND_HELP2, COMMAND_DESCRIPTORS, IMESSAGE_DOCS = `# CLAUDE.md
 
 ## Project Overview
 
@@ -19258,12 +19832,12 @@ 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.
 `, commandInputSchema, conversationListInputSchema, conversationGetInputSchema, messageListInputSchema, messageSendInputSchema, messageReplyInputSchema, imessageConnector;
 var init_imessage = __esm(() => {
   init_package();
   init_zod();
-  init_database();
+  init_connector_resolver();
   init_connector();
   COMMAND_SPECS = [
     {
@@ -19487,7 +20061,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);
         }
       }
     },
@@ -19551,18 +20125,18 @@ var init_imessage = __esm(() => {
 });
 
 // src/core/connectors/stripe.ts
-import { existsSync as existsSync10 } from "fs";
-import { dirname as dirname4, join as join10 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
 function resolveStripeConnectorDir() {
   const candidates = [
-    join10(__dirname3, "..", "..", "..", "connectors", "connect-stripe"),
-    join10(__dirname3, "..", "..", "connectors", "connect-stripe"),
-    join10(__dirname3, "..", "connectors", "connect-stripe"),
-    join10(process.cwd(), "connectors", "connect-stripe")
+    join11(__dirname3, "..", "..", "..", "connectors", "stripe"),
+    join11(__dirname3, "..", "..", "connectors", "stripe"),
+    join11(__dirname3, "..", "connectors", "stripe"),
+    join11(process.cwd(), "connectors", "stripe")
   ];
   for (const candidate of candidates) {
-    if (existsSync10(candidate)) {
+    if (existsSync11(candidate)) {
       return candidate;
     }
   }
@@ -19610,10 +20184,10 @@ function buildCommandHelp2(spec) {
 `);
 }
 async function loadStripeApiModule() {
-  return await import(pathToFileURL2(join10(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
+  return await import(pathToFileURL2(join11(CONNECTOR_DIR2, "src", "api", "index.ts")).href);
 }
 async function loadStripeConfigModule() {
-  return await import(pathToFileURL2(join10(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
+  return await import(pathToFileURL2(join11(CONNECTOR_DIR2, "src", "utils", "config.ts")).href);
 }
 function extractGlobalArgs3(args) {
   const remaining = [];
@@ -20431,10 +21005,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,
@@ -26576,8 +27152,8 @@ __export(exports_registry, {
   CONNECTORS: () => CONNECTORS,
   CATEGORIES: () => CATEGORIES
 });
-import { existsSync as existsSync11, readFileSync as readFileSync4 } from "fs";
-import { join as join11, dirname as dirname5 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync5 } from "fs";
+import { join as join12, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getConnectorsByCategory(category) {
   return CONNECTORS.filter((c) => c.category === category);
@@ -26730,7 +27306,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);
 }
 function loadConnectorVersions() {
   if (versionsLoaded)
@@ -26738,17 +27317,17 @@ function loadConnectorVersions() {
   versionsLoaded = true;
   const thisDir = dirname5(fileURLToPath3(import.meta.url));
   const candidates = [
-    join11(thisDir, "..", "connectors"),
-    join11(thisDir, "..", "..", "connectors")
+    join12(thisDir, "..", "connectors"),
+    join12(thisDir, "..", "..", "connectors")
   ];
-  const connectorsDir = candidates.find((d) => existsSync11(d));
+  const connectorsDir = candidates.find((d) => existsSync12(d));
   if (!connectorsDir)
     return;
   for (const connector of CONNECTORS) {
     try {
-      const pkgPath = join11(connectorsDir, `connect-${connector.name}`, "package.json");
-      if (existsSync11(pkgPath)) {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+      const pkgPath = join12(getConnectorPackagePath(connectorsDir, connector.name), "package.json");
+      if (existsSync12(pkgPath)) {
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         connector.version = pkg.version || "0.0.0";
         continue;
       }
@@ -26763,6 +27342,7 @@ var CATEGORIES, CONNECTORS, versionsLoaded = false;
 var init_registry2 = __esm(() => {
   init_builtins();
   init_synonyms();
+  init_connector_resolver();
   init_ai_ml();
   init_advertising();
   init_business_tools();
@@ -28471,37 +29051,34 @@ __export(exports_installer, {
   getConnectorDocs: () => getConnectorDocs,
   connectorExists: () => connectorExists
 });
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync4, readdirSync as readdirSync7, statSync as statSync3, rmSync as rmSync2 } from "fs";
-import { join as join12, dirname as dirname6 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, readdirSync as readdirSync7, statSync as statSync4, rmSync as rmSync2 } from "fs";
+import { join as join13, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function resolveConnectorsDir() {
-  const fromBin = join12(__dirname4, "..", "connectors");
-  if (existsSync12(fromBin))
+  const fromBin = join13(__dirname4, "..", "connectors");
+  if (existsSync13(fromBin))
     return fromBin;
-  const fromSrc = join12(__dirname4, "..", "..", "connectors");
-  if (existsSync12(fromSrc))
+  const fromSrc = join13(__dirname4, "..", "..", "connectors");
+  if (existsSync13(fromSrc))
     return fromSrc;
   return fromBin;
 }
-function normalizeConnectorName(name) {
-  return name.startsWith("connect-") ? name.slice("connect-".length) : name;
-}
 function getProjectConnectorsDir(targetDir) {
-  return join12(targetDir, PROJECT_CONNECTORS_DIRNAME);
+  return join13(targetDir, PROJECT_CONNECTORS_DIRNAME);
 }
 function getEnablementManifestPath(targetDir) {
-  return join12(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
+  return join13(getProjectConnectorsDir(targetDir), ENABLEMENT_MANIFEST_FILENAME);
 }
 function getLegacyInstallPath(targetDir, name) {
-  return join12(getProjectConnectorsDir(targetDir), `connect-${normalizeConnectorName(name)}`);
+  return join13(getProjectConnectorsDir(targetDir), legacyConnectorName(name));
 }
 function loadEnablementManifest(targetDir) {
   const manifestPath = getEnablementManifestPath(targetDir);
-  if (!existsSync12(manifestPath)) {
+  if (!existsSync13(manifestPath)) {
     return null;
   }
   try {
-    const raw = JSON.parse(readFileSync5(manifestPath, "utf-8"));
+    const raw = JSON.parse(readFileSync6(manifestPath, "utf-8"));
     if (!Array.isArray(raw.connectors)) {
       return null;
     }
@@ -28517,12 +29094,12 @@ function loadEnablementManifest(targetDir) {
 }
 function getLegacyInstalledConnectors(targetDir) {
   const connectorsDir = getProjectConnectorsDir(targetDir);
-  if (!existsSync12(connectorsDir)) {
+  if (!existsSync13(connectorsDir)) {
     return [];
   }
   return readdirSync7(connectorsDir).filter((entry) => {
-    const fullPath = join12(connectorsDir, entry);
-    return entry.startsWith("connect-") && statSync3(fullPath).isDirectory();
+    const fullPath = join13(connectorsDir, entry);
+    return entry.startsWith("connect-") && statSync4(fullPath).isDirectory();
   }).map((entry) => entry.replace("connect-", "")).sort();
 }
 function getEnabledConnectors(targetDir) {
@@ -28530,7 +29107,7 @@ function getEnabledConnectors(targetDir) {
   return [...new Set([...manifestConnectors, ...getLegacyInstalledConnectors(targetDir)])].sort();
 }
 function updateConnectorsIndex(connectorsDir, connectors18) {
-  const indexPath = join12(connectorsDir, ENABLEMENT_INDEX_FILENAME);
+  const indexPath = join13(connectorsDir, ENABLEMENT_INDEX_FILENAME);
   const connectorList = connectors18.map((connector) => `  "${connector}",`).join(`
 `);
   const content = `/**
@@ -28546,28 +29123,27 @@ ${connectorList}
 
 export type EnabledConnectorName = typeof enabledConnectors[number];
 `;
-  writeFileSync4(indexPath, content);
+  writeFileSync5(indexPath, content);
 }
 function writeEnablementManifest(targetDir, connectors18) {
   const connectorsDir = getProjectConnectorsDir(targetDir);
-  mkdirSync7(connectorsDir, { recursive: true });
+  mkdirSync6(connectorsDir, { recursive: true });
   const manifest = {
     version: 1,
     mode: "internal",
     updatedAt: new Date().toISOString(),
     connectors: [...new Set(connectors18.map((value) => normalizeConnectorName(value)))].sort()
   };
-  writeFileSync4(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 join12(CONNECTORS_DIR, connectorName);
+  return getConnectorPackagePath(CONNECTORS_DIR, name);
 }
 function connectorExists(name) {
   const normalizedName = normalizeConnectorName(name);
-  return hasInternalConnectorDefinition(normalizedName) || existsSync12(getConnectorPath(normalizedName));
+  return hasInternalConnectorDefinition(normalizedName) || existsSync13(getConnectorPath(normalizedName));
 }
 function installConnector(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
@@ -28600,7 +29176,7 @@ function installConnector(name, options = {}) {
   try {
     const nextEnabled = [...new Set([...installed, normalizedName])].sort();
     writeEnablementManifest(targetDir, nextEnabled);
-    if (overwrite && existsSync12(legacyInstallPath)) {
+    if (overwrite && existsSync13(legacyInstallPath)) {
       rmSync2(legacyInstallPath, { recursive: true });
     }
     return {
@@ -28635,9 +29211,9 @@ function parseConnectorDocs(raw) {
 function getConnectorDocs(name) {
   const normalizedName = normalizeConnectorName(name);
   const connectorPath = getConnectorPath(normalizedName);
-  const claudeMdPath = join12(connectorPath, "CLAUDE.md");
-  if (existsSync12(claudeMdPath)) {
-    return parseConnectorDocs(readFileSync5(claudeMdPath, "utf-8"));
+  const claudeMdPath = join13(connectorPath, "CLAUDE.md");
+  if (existsSync13(claudeMdPath)) {
+    return parseConnectorDocs(readFileSync6(claudeMdPath, "utf-8"));
   }
   const internalDocs = getInternalConnectorDefinition(normalizedName)?.docsMarkdown;
   if (internalDocs) {
@@ -28681,7 +29257,7 @@ function removeConnector(name, targetDir = process.cwd()) {
   const nextEnabled = installed.filter((connector) => connector !== normalizedName);
   writeEnablementManifest(targetDir, nextEnabled);
   const legacyInstallPath = getLegacyInstallPath(targetDir, normalizedName);
-  if (existsSync12(legacyInstallPath)) {
+  if (existsSync13(legacyInstallPath)) {
     rmSync2(legacyInstallPath, { recursive: true });
   }
   return true;
@@ -28689,29 +29265,29 @@ function removeConnector(name, targetDir = process.cwd()) {
 var __dirname4, CONNECTORS_DIR, PROJECT_CONNECTORS_DIRNAME = ".connectors", ENABLEMENT_MANIFEST_FILENAME = "manifest.json", ENABLEMENT_INDEX_FILENAME = "index.ts";
 var init_installer = __esm(() => {
   init_builtins();
+  init_connector_resolver();
   __dirname4 = dirname6(fileURLToPath4(import.meta.url));
   CONNECTORS_DIR = resolveConnectorsDir();
 });
 
 // src/lib/lock.ts
-import { openSync, closeSync, unlinkSync as unlinkSync2, existsSync as existsSync13, statSync as statSync5 } from "fs";
-import { join as join14 } from "path";
-import { mkdirSync as mkdirSync8 } from "fs";
+import { openSync, closeSync, unlinkSync as unlinkSync2, existsSync as existsSync14, statSync as statSync6 } from "fs";
+import { mkdirSync as mkdirSync7 } from "fs";
 function lockPath(connector) {
-  const dir = join14(getConnectorsHome(), `connect-${connector}`);
-  mkdirSync8(dir, { recursive: true });
-  return join14(dir, ".write.lock");
+  const dir = getConnectorConfigDir(connector);
+  mkdirSync7(dir, { recursive: true });
+  return `${dir}/.write.lock`;
 }
 function isStale(path) {
   try {
-    const stat = statSync5(path);
+    const stat = statSync6(path);
     return Date.now() - stat.mtimeMs > STALE_LOCK_MS;
   } catch {
     return false;
   }
 }
 function tryAcquire(path) {
-  if (existsSync13(path) && isStale(path)) {
+  if (existsSync14(path) && isStale(path)) {
     try {
       unlinkSync2(path);
     } catch {}
@@ -28732,6 +29308,7 @@ function release(path) {
   } catch {}
 }
 async function withWriteLock(connector, fn) {
+  connector = normalizeConnectorName(connector);
   const path = lockPath(connector);
   const deadline = Date.now() + LOCK_TIMEOUT_MS;
   while (Date.now() < deadline) {
@@ -28748,7 +29325,7 @@ async function withWriteLock(connector, fn) {
 }
 var LOCK_TIMEOUT_MS = 5000, LOCK_RETRY_MS = 100, STALE_LOCK_MS = 30000, LockTimeoutError;
 var init_lock = __esm(() => {
-  init_database();
+  init_connector_resolver();
   LockTimeoutError = class LockTimeoutError extends Error {
     connector;
     constructor(connector) {
@@ -28760,10 +29337,11 @@ var init_lock = __esm(() => {
 });
 
 // src/server/auth.ts
-import { existsSync as existsSync14, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync9, readdirSync as readdirSync9, rmSync as rmSync3, statSync as statSync6 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8, readdirSync as readdirSync9, rmSync as rmSync3, statSync as statSync7 } from "fs";
 import { randomBytes } from "crypto";
 import { join as join15 } from "path";
 function getAuthType(name) {
+  name = normalizeConnectorName(name);
   const docs = getConnectorDocs(name);
   if (!docs?.auth)
     return "apikey";
@@ -28774,53 +29352,65 @@ function getAuthType(name) {
     return "bearer";
   return "apikey";
 }
-function getConnectorConfigDir(name) {
-  const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  return join15(getConnectorsHome(), connectorName);
+function getConnectorConfigDir2(name) {
+  name = normalizeConnectorName(name);
+  return getConnectorConfigDir(name);
+}
+function getConnectorConfigReadDirs2(name) {
+  name = normalizeConnectorName(name);
+  return getConnectorConfigReadDirs(name);
 }
 function getCurrentProfile2(name) {
-  const configDir = getConnectorConfigDir(name);
-  const currentProfileFile = join15(configDir, "current_profile");
-  if (existsSync14(currentProfileFile)) {
-    try {
-      return readFileSync6(currentProfileFile, "utf-8").trim() || "default";
-    } catch {
-      return "default";
+  name = normalizeConnectorName(name);
+  for (const configDir of getConnectorConfigReadDirs2(name)) {
+    const currentProfileFile = join15(configDir, "current_profile");
+    if (existsSync15(currentProfileFile)) {
+      try {
+        return readFileSync7(currentProfileFile, "utf-8").trim() || "default";
+      } catch {
+        return "default";
+      }
     }
   }
   return "default";
 }
-function loadProfileConfig(name) {
-  const configDir = getConnectorConfigDir(name);
-  const profile = getCurrentProfile2(name);
+function loadProfileConfigFromDir(configDir, profile) {
   let flatConfig = {};
   let dirConfig = {};
   const profileFile = join15(configDir, "profiles", `${profile}.json`);
-  if (existsSync14(profileFile)) {
+  if (existsSync15(profileFile)) {
     try {
-      flatConfig = JSON.parse(readFileSync6(profileFile, "utf-8"));
+      flatConfig = JSON.parse(readFileSync7(profileFile, "utf-8"));
     } catch {}
   }
   const profileDirConfig = join15(configDir, "profiles", profile, "config.json");
-  if (existsSync14(profileDirConfig)) {
+  if (existsSync15(profileDirConfig)) {
     try {
-      dirConfig = JSON.parse(readFileSync6(profileDirConfig, "utf-8"));
+      dirConfig = JSON.parse(readFileSync7(profileDirConfig, "utf-8"));
     } catch {}
   }
-  if (Object.keys(flatConfig).length === 0 && Object.keys(dirConfig).length === 0) {
-    return {};
-  }
   return { ...flatConfig, ...dirConfig };
 }
-function loadTokens2(name) {
-  const configDir = getConnectorConfigDir(name);
+function loadProfileConfig(name) {
+  name = normalizeConnectorName(name);
   const profile = getCurrentProfile2(name);
-  const tokensFile = join15(configDir, "profiles", profile, "tokens.json");
-  if (existsSync14(tokensFile)) {
-    try {
-      return JSON.parse(readFileSync6(tokensFile, "utf-8"));
-    } catch {
-      return null;
+  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 = join15(configDir, "profiles", profile, "tokens.json");
+    if (existsSync15(tokensFile)) {
+      try {
+        return JSON.parse(readFileSync7(tokensFile, "utf-8"));
+      } catch {
+        return null;
+      }
     }
   }
   const profileConfig = loadProfileConfig(name);
@@ -28854,10 +29444,11 @@ function isStoredOAuthEnvVarSet(variable, oauthConfig, tokens, profileConfig) {
   return false;
 }
 function getAuthStatus(name) {
+  name = normalizeConnectorName(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,
@@ -28895,56 +29486,60 @@ function getAuthStatus(name) {
   };
 }
 function getEnvVars(name) {
+  name = normalizeConnectorName(name);
   const docs = getConnectorDocs(name);
   return docs?.envVars || [];
 }
 async function saveApiKey(name, key, field) {
+  name = normalizeConnectorName(name);
   return withWriteLock(name, () => _saveApiKey(name, key, field));
 }
 function _saveApiKey(name, key, field) {
-  const configDir = getConnectorConfigDir(name);
+  name = normalizeConnectorName(name);
+  const configDir = getConnectorConfigDir2(name);
   const profile = getCurrentProfile2(name);
   const keyField = field || guessKeyField(name);
   if (keyField === "clientId" || keyField === "clientSecret") {
     const credentialsFile = join15(configDir, "credentials.json");
-    mkdirSync9(configDir, { recursive: true });
+    mkdirSync8(configDir, { recursive: true });
     let creds = {};
-    if (existsSync14(credentialsFile)) {
+    if (existsSync15(credentialsFile)) {
       try {
-        creds = JSON.parse(readFileSync6(credentialsFile, "utf-8"));
+        creds = JSON.parse(readFileSync7(credentialsFile, "utf-8"));
       } catch {}
     }
     creds[keyField] = key;
-    writeFileSync5(credentialsFile, JSON.stringify(creds, null, 2));
+    writeFileSync6(credentialsFile, JSON.stringify(creds, null, 2));
     return;
   }
   const profileFile = join15(configDir, "profiles", `${profile}.json`);
   const profileDir = join15(configDir, "profiles", profile);
-  if (existsSync14(profileFile)) {
+  if (existsSync15(profileFile)) {
     let config = {};
     try {
-      config = JSON.parse(readFileSync6(profileFile, "utf-8"));
+      config = JSON.parse(readFileSync7(profileFile, "utf-8"));
     } catch {}
     config[keyField] = key;
-    writeFileSync5(profileFile, JSON.stringify(config, null, 2));
+    writeFileSync6(profileFile, JSON.stringify(config, null, 2));
     return;
   }
-  if (existsSync14(profileDir)) {
+  if (existsSync15(profileDir)) {
     const configFile = join15(profileDir, "config.json");
     let config = {};
-    if (existsSync14(configFile)) {
+    if (existsSync15(configFile)) {
       try {
-        config = JSON.parse(readFileSync6(configFile, "utf-8"));
+        config = JSON.parse(readFileSync7(configFile, "utf-8"));
       } catch {}
     }
     config[keyField] = key;
-    writeFileSync5(configFile, JSON.stringify(config, null, 2));
+    writeFileSync6(configFile, JSON.stringify(config, null, 2));
     return;
   }
-  mkdirSync9(profileDir, { recursive: true });
-  writeFileSync5(join15(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
+  mkdirSync8(profileDir, { recursive: true });
+  writeFileSync6(join15(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
 }
 function guessKeyField(name) {
+  name = normalizeConnectorName(name);
   const docs = getConnectorDocs(name);
   if (!docs?.envVars.length)
     return "apiKey";
@@ -28959,13 +29554,15 @@ function guessKeyField(name) {
   return "apiKey";
 }
 function getOAuthConfig(name) {
-  const configDir = getConnectorConfigDir(name);
-  const credentialsFile = join15(configDir, "credentials.json");
-  if (existsSync14(credentialsFile)) {
-    try {
-      const creds = JSON.parse(readFileSync6(credentialsFile, "utf-8"));
-      return { clientId: creds.clientId, clientSecret: creds.clientSecret };
-    } catch {}
+  name = normalizeConnectorName(name);
+  for (const configDir of getConnectorConfigReadDirs2(name)) {
+    const credentialsFile = join15(configDir, "credentials.json");
+    if (existsSync15(credentialsFile)) {
+      try {
+        const creds = JSON.parse(readFileSync7(credentialsFile, "utf-8"));
+        return { clientId: creds.clientId, clientSecret: creds.clientSecret };
+      } catch {}
+    }
   }
   const config = loadProfileConfig(name);
   return {
@@ -28974,6 +29571,7 @@ function getOAuthConfig(name) {
   };
 }
 function getOAuthStartUrl(name, redirectUri) {
+  name = normalizeConnectorName(name);
   const oauthConfig = getOAuthConfig(name);
   if (!oauthConfig.clientId)
     return null;
@@ -28999,6 +29597,7 @@ function getOAuthStartUrl(name, redirectUri) {
   return `${GOOGLE_AUTH_URL}?${params.toString()}`;
 }
 function validateOAuthState(state, expectedConnector) {
+  expectedConnector = normalizeConnectorName(expectedConnector);
   if (!state)
     return false;
   const entry = oauthStateStore.get(state);
@@ -29008,6 +29607,7 @@ function validateOAuthState(state, expectedConnector) {
   return Date.now() - entry.createdAt < 10 * 60 * 1000;
 }
 async function exchangeOAuthCode(name, code, redirectUri) {
+  name = normalizeConnectorName(name);
   const oauthConfig = getOAuthConfig(name);
   if (!oauthConfig.clientId || !oauthConfig.clientSecret) {
     throw new Error("OAuth credentials not configured for " + name);
@@ -29040,19 +29640,22 @@ async function exchangeOAuthCode(name, code, redirectUri) {
   return tokens;
 }
 function saveOAuthTokens(name, tokens) {
-  const configDir = getConnectorConfigDir(name);
+  name = normalizeConnectorName(name);
+  const configDir = getConnectorConfigDir2(name);
   const profile = getCurrentProfile2(name);
   const profileDir = join15(configDir, "profiles", profile);
-  mkdirSync9(profileDir, { recursive: true });
+  mkdirSync8(profileDir, { recursive: true });
   const tokensFile = join15(profileDir, "tokens.json");
-  writeFileSync5(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
+  writeFileSync6(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 async function refreshOAuthToken(name) {
+  name = normalizeConnectorName(name);
   return withWriteLock(name, () => _refreshOAuthToken(name));
 }
 async function _refreshOAuthToken(name) {
+  name = normalizeConnectorName(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);
   }
@@ -29085,39 +29688,43 @@ async function _refreshOAuthToken(name) {
   saveOAuthTokens(name, tokens);
   return tokens;
 }
-function listProfiles3(name) {
-  const configDir = getConnectorConfigDir(name);
-  const profilesDir = join15(configDir, "profiles");
-  if (!existsSync14(profilesDir))
-    return ["default"];
+function listProfiles4(name) {
+  name = normalizeConnectorName(name);
   const seen = new Set;
-  try {
-    const entries = readdirSync9(profilesDir);
-    for (const entry of entries) {
-      const fullPath = join15(profilesDir, entry);
-      const stat = statSync6(fullPath);
-      if (stat.isDirectory()) {
-        seen.add(entry);
-      } else if (entry.endsWith(".json")) {
-        seen.add(entry.replace(/\.json$/, ""));
+  for (const configDir of getConnectorConfigReadDirs2(name)) {
+    const profilesDir = join15(configDir, "profiles");
+    if (!existsSync15(profilesDir))
+      continue;
+    try {
+      const entries = readdirSync9(profilesDir);
+      for (const entry of entries) {
+        const fullPath = join15(profilesDir, entry);
+        const stat = statSync7(fullPath);
+        if (stat.isDirectory()) {
+          seen.add(entry);
+        } else if (entry.endsWith(".json")) {
+          seen.add(entry.replace(/\.json$/, ""));
+        }
       }
-    }
-  } catch {}
+    } catch {}
+  }
   seen.add("default");
   return Array.from(seen).sort();
 }
 function switchProfile(name, profile) {
-  const configDir = getConnectorConfigDir(name);
-  mkdirSync9(configDir, { recursive: true });
-  writeFileSync5(join15(configDir, "current_profile"), profile);
+  name = normalizeConnectorName(name);
+  const configDir = getConnectorConfigDir2(name);
+  mkdirSync8(configDir, { recursive: true });
+  writeFileSync6(join15(configDir, "current_profile"), profile);
 }
 function deleteProfile2(name, profile) {
+  name = normalizeConnectorName(name);
   if (profile === "default")
     return false;
-  const configDir = getConnectorConfigDir(name);
+  const configDir = getConnectorConfigDir2(name);
   const profilesDir = join15(configDir, "profiles");
   const profileFile = join15(profilesDir, `${profile}.json`);
-  if (existsSync14(profileFile)) {
+  if (existsSync15(profileFile)) {
     rmSync3(profileFile);
     if (getCurrentProfile2(name) === profile) {
       switchProfile(name, "default");
@@ -29125,7 +29732,7 @@ function deleteProfile2(name, profile) {
     return true;
   }
   const profileDir = join15(profilesDir, profile);
-  if (existsSync14(profileDir)) {
+  if (existsSync15(profileDir)) {
     rmSync3(profileDir, { recursive: true });
     if (getCurrentProfile2(name) === profile) {
       switchProfile(name, "default");
@@ -29138,7 +29745,7 @@ var FETCH_TIMEOUT = 1e4, oauthStateStore, GOOGLE_AUTH_URL = "https://accounts.go
 var init_auth = __esm(() => {
   init_installer();
   init_lock();
-  init_database();
+  init_connector_resolver();
   oauthStateStore = new Map;
   GOOGLE_SCOPES = {
     gmail: [
@@ -29388,25 +29995,25 @@ var init_rate = __esm(() => {
 });
 
 // src/lib/llm.ts
-import { existsSync as existsSync15, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync10 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync9 } from "fs";
 import { join as join16 } from "path";
 function getLlmConfigPath() {
   return join16(getConnectorsHome(), "llm.json");
 }
 function getLlmConfig() {
   const path = getLlmConfigPath();
-  if (!existsSync15(path))
+  if (!existsSync16(path))
     return null;
   try {
-    return JSON.parse(readFileSync7(path, "utf-8"));
+    return JSON.parse(readFileSync8(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveLlmConfig(config) {
   const dir = getConnectorsHome();
-  mkdirSync10(dir, { recursive: true });
-  writeFileSync6(getLlmConfigPath(), JSON.stringify(config, null, 2));
+  mkdirSync9(dir, { recursive: true });
+  writeFileSync7(getLlmConfigPath(), JSON.stringify(config, null, 2));
 }
 function setLlmStrip(enabled) {
   const config = getLlmConfig();
@@ -29844,16 +30451,16 @@ var init_workflow_runner = __esm(() => {
 });
 
 // src/lib/runner.ts
-import { existsSync as existsSync16, readdirSync as readdirSync10 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync10 } from "fs";
 import { join as join17, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { spawn as spawn2 } from "child_process";
 function resolveConnectorsDir2() {
   const fromBin = join17(__dirname5, "..", "connectors");
-  if (existsSync16(fromBin))
+  if (existsSync17(fromBin))
     return fromBin;
   const fromSrc = join17(__dirname5, "..", "..", "connectors");
-  if (existsSync16(fromSrc))
+  if (existsSync17(fromSrc))
     return fromSrc;
   return fromBin;
 }
@@ -29874,8 +30481,9 @@ function getInternalCommandRuntime(name) {
 }
 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`;
@@ -29896,10 +30504,10 @@ function buildEnvWithCredentials(connectorName, baseEnv) {
       }
     }
   }
-  if (getAuthType(connectorName) === "oauth") {
-    const oauthConfig = getOAuthConfig(connectorName);
-    const tokens = loadTokens2(connectorName);
-    for (const { variable } of getEnvVars(connectorName)) {
+  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) {
@@ -29918,10 +30526,10 @@ function buildEnvWithCredentials(connectorName, baseEnv) {
   return env;
 }
 function getConnectorCliPath(name) {
-  const safeName = name.replace(/[^a-z0-9-]/g, "");
-  const connectorDir = join17(CONNECTORS_DIR2, `connect-${safeName}`);
+  const safeName = normalizeConnectorName(name).replace(/[^a-z0-9-]/g, "");
+  const connectorDir = getConnectorPackagePath(CONNECTORS_DIR2, safeName);
   const cliPath = join17(connectorDir, "src", "cli", "index.ts");
-  if (existsSync16(cliPath))
+  if (existsSync17(cliPath))
     return cliPath;
   return null;
 }
@@ -29976,8 +30584,9 @@ function parseCommanderHelpOperations(helpText) {
   return operations;
 }
 function runConnectorCommand2(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) {
@@ -29991,17 +30600,125 @@ function runConnectorCommand2(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 runConnectorCommand2(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
     });
@@ -30009,7 +30726,7 @@ function runLegacyConnectorCommand(name, args, timeoutMs = 30000) {
   return new Promise((resolve) => {
     const proc = spawn2("bun", ["run", cliPath, ...args], {
       timeout: timeoutMs,
-      env: buildEnvWithCredentials(name, process.env),
+      env: buildEnvWithCredentials(connectorName, process.env),
       stdio: ["pipe", "pipe", "pipe"]
     });
     let stdout = "";
@@ -30039,7 +30756,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,
@@ -30051,15 +30769,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 runConnectorCommand2(name, ["--help"]);
+  const result = await runConnectorCommand2(connectorName, ["--help"]);
   const helpText = result.stdout || result.stderr;
   const operations = parseCommanderHelpOperations(helpText);
   return {
@@ -30070,7 +30788,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) {
@@ -30081,7 +30800,7 @@ async function getConnectorCommandHelp(name, command) {
   if (runtimeCommand?.helpText) {
     return runtimeCommand.helpText;
   }
-  const result = await runConnectorCommand2(name, [command, "--help"]);
+  const result = await runConnectorCommand2(connectorName, [command, "--help"]);
   return result.stdout || result.stderr;
 }
 var __dirname5, CONNECTORS_DIR2, ENV_VAR_NAME_OVERRIDES;
@@ -30090,6 +30809,7 @@ var init_runner = __esm(() => {
   init_connector();
   init_database();
   init_auth();
+  init_connector_resolver();
   __dirname5 = dirname7(fileURLToPath5(import.meta.url));
   CONNECTORS_DIR2 = resolveConnectorsDir2();
   ENV_VAR_NAME_OVERRIDES = {
@@ -30101,13 +30821,88 @@ var init_runner = __esm(() => {
   };
 });
 
+// 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
+  };
+}
+var init_manifest = __esm(() => {
+  init_package();
+  init_registry2();
+  init_installer();
+  init_runner();
+  init_auth();
+  init_connector_resolver();
+  init_builtins();
+});
+
 // src/server/serve.ts
 var exports_serve = {};
 __export(exports_serve, {
   startServer: () => startServer
 });
-import { existsSync as existsSync17, readdirSync as readdirSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync11 } from "fs";
-import { join as join18, dirname as dirname8, extname, basename as basename2 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync8, mkdirSync as mkdirSync10 } from "fs";
+import { join as join18, dirname as dirname8, extname, basename as basename3 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function logActivity(action, connector, detail) {
   activityLog.unshift({ action, connector, timestamp: Date.now(), detail });
@@ -30129,7 +30924,7 @@ function resolveDashboardDir() {
   }
   candidates.push(join18(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync17(candidate))
+    if (existsSync18(candidate))
       return candidate;
   }
   return join18(process.cwd(), "dashboard", "dist");
@@ -30162,9 +30957,6 @@ function htmlResponse(content, status = 200) {
     headers: { "Content-Type": "text/html; charset=utf-8", ...SECURITY_HEADERS }
   });
 }
-function isValidConnectorName(name) {
-  return /^[a-z0-9-]+$/.test(name);
-}
 function getAllConnectorsWithAuth() {
   const installed = new Set(getInstalledConnectors());
   return CONNECTORS.map((meta) => {
@@ -30217,7 +31009,7 @@ function oauthPage(type, title, message, hint, extra) {
   </body></html>`;
 }
 function serveStaticFile(filePath) {
-  if (!existsSync17(filePath))
+  if (!existsSync18(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -30254,7 +31046,7 @@ async function startServer(requestedPort, options) {
   const strict = options?.strict ?? false;
   loadConnectorVersions();
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync17(dashboardDir);
+  const dashboardExists = existsSync18(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -30297,6 +31089,15 @@ Dashboard not found at: ${dashboardDir}`);
         }
         return jsonStripped(data, 200, port);
       }
+      if (path === "/api/connectors/manifest" && method === "GET") {
+        const connectorNames = url2.searchParams.get("connectors")?.split(",").map((name) => name.trim()).filter(Boolean);
+        const includeOperations = url2.searchParams.get("includeOperations") === "true";
+        const manifest = await getConnectorCapabilityManifest({
+          includeOperations,
+          ...connectorNames ? { connectorNames } : {}
+        });
+        return json(manifest, 200, port);
+      }
       const singleMatch = path.match(/^\/api\/connectors\/([^/]+)$/);
       if (singleMatch && method === "GET") {
         const name = singleMatch[1];
@@ -30370,6 +31171,20 @@ Dashboard not found at: ${dashboardDir}`);
             return json({ error: "Request body too large" }, 413, port);
           }
           const body = await req.json();
+          if (typeof body.operation === "string" && body.operation.trim()) {
+            const result2 = await runConnectorOperation({
+              connector: name,
+              operation: body.operation,
+              input: body.input,
+              profile: body.profile,
+              timeoutMs: body.timeout ?? 30000,
+              parseJson: body.parseJson
+            });
+            if (!result2.success) {
+              return json({ displayName: meta.displayName, ...result2 }, 400, port);
+            }
+            return json({ displayName: meta.displayName, ...result2 }, 200, port);
+          }
           const args = Array.isArray(body.args) ? body.args.filter((value) => typeof value === "string") : [];
           if (args.length === 0) {
             return json({ error: "Missing connector command arguments" }, 400, port);
@@ -30656,14 +31471,16 @@ ${result.stderr}`;
         if (!isValidConnectorName(name))
           return json({ error: "Invalid connector name" }, 400, port);
         try {
-          const profiles = listProfiles3(name);
-          const configDir = join18(getConnectorsHome(), name.startsWith("connect-") ? name : `connect-${name}`);
-          const currentProfileFile = join18(configDir, "current_profile");
+          const profiles = listProfiles4(name);
           let current = "default";
-          if (existsSync17(currentProfileFile)) {
-            try {
-              current = readFileSync8(currentProfileFile, "utf-8").trim() || "default";
-            } catch {}
+          for (const configDir of getConnectorConfigReadDirs(name)) {
+            const currentProfileFile = join18(configDir, "current_profile");
+            if (existsSync18(currentProfileFile)) {
+              try {
+                current = readFileSync9(currentProfileFile, "utf-8").trim() || "default";
+              } catch {}
+              break;
+            }
           }
           return json({ current, profiles }, 200, port);
         } catch (e) {
@@ -30711,33 +31528,31 @@ ${result.stderr}`;
         try {
           const connectDir = getConnectorsHome();
           const result = {};
-          if (existsSync17(connectDir)) {
-            const entries = readdirSync11(connectDir, { withFileTypes: true });
-            for (const entry of entries) {
-              if (!entry.isDirectory() || !entry.name.startsWith("connect-"))
-                continue;
-              const connectorName = entry.name.replace(/^connect-/, "");
-              const profilesDir = join18(connectDir, entry.name, "profiles");
-              if (!existsSync17(profilesDir))
-                continue;
+          if (existsSync18(connectDir)) {
+            for (const connectorName of listConfiguredConnectorNames(connectDir)) {
               const profiles = {};
-              const profileEntries = readdirSync11(profilesDir, { withFileTypes: true });
-              for (const pEntry of profileEntries) {
-                if (pEntry.isFile() && pEntry.name.endsWith(".json")) {
-                  const profileName = basename2(pEntry.name, ".json");
-                  try {
-                    const config = JSON.parse(readFileSync8(join18(profilesDir, pEntry.name), "utf-8"));
-                    profiles[profileName] = config;
-                  } catch {}
-                }
-                if (pEntry.isDirectory()) {
-                  const configPath = join18(profilesDir, pEntry.name, "config.json");
-                  if (existsSync17(configPath)) {
+              for (const configDir of [...getConnectorConfigReadDirs(connectorName, connectDir)].reverse()) {
+                const profilesDir = join18(configDir, "profiles");
+                if (!existsSync18(profilesDir))
+                  continue;
+                const profileEntries = readdirSync11(profilesDir, { withFileTypes: true });
+                for (const pEntry of profileEntries) {
+                  if (pEntry.isFile() && pEntry.name.endsWith(".json")) {
+                    const profileName = basename3(pEntry.name, ".json");
                     try {
-                      const config = JSON.parse(readFileSync8(configPath, "utf-8"));
-                      profiles[pEntry.name] = config;
+                      const config = JSON.parse(readFileSync9(join18(profilesDir, pEntry.name), "utf-8"));
+                      profiles[profileName] = config;
                     } catch {}
                   }
+                  if (pEntry.isDirectory()) {
+                    const configPath = join18(profilesDir, pEntry.name, "config.json");
+                    if (existsSync18(configPath)) {
+                      try {
+                        const config = JSON.parse(readFileSync9(configPath, "utf-8"));
+                        profiles[pEntry.name] = config;
+                      } catch {}
+                    }
+                  }
                 }
               }
               if (Object.keys(profiles).length > 0) {
@@ -30775,14 +31590,14 @@ ${result.stderr}`;
               continue;
             if (!data.profiles || typeof data.profiles !== "object")
               continue;
-            const connectorDir = join18(connectDir, `connect-${connectorName}`);
+            const connectorDir = getConnectorConfigDir(connectorName, connectDir);
             const profilesDir = join18(connectorDir, "profiles");
             for (const [profileName, config] of Object.entries(data.profiles)) {
               if (!config || typeof config !== "object")
                 continue;
-              mkdirSync11(profilesDir, { recursive: true });
+              mkdirSync10(profilesDir, { recursive: true });
               const profileFile = join18(profilesDir, `${profileName}.json`);
-              writeFileSync7(profileFile, JSON.stringify(config, null, 2));
+              writeFileSync8(profileFile, JSON.stringify(config, null, 2));
               imported++;
             }
           }
@@ -30798,7 +31613,7 @@ ${result.stderr}`;
         const redirectUri = `http://localhost:${port}/oauth/${name}/callback`;
         const authUrl = getOAuthStartUrl(name, redirectUri);
         if (!authUrl) {
-          return htmlResponse(oauthPage("warning", "OAuth Not Available", `No OAuth client credentials found for <span class="connector">${name}</span>.`, `Run <code>connectors auth ${name}</code> or add credentials at <code>~/.hasna/connectors/connect-${name}/credentials.json</code>`));
+          return htmlResponse(oauthPage("warning", "OAuth Not Available", `No OAuth client credentials found for <span class="connector">${name}</span>.`, `Run <code>connectors auth ${name}</code> or add credentials at <code>~/.hasna/connectors/${name}/credentials.json</code>`));
         }
         return Response.redirect(authUrl, 302);
       }
@@ -30882,7 +31697,9 @@ var init_serve = __esm(() => {
   init_database();
   init_registry2();
   init_installer();
+  init_connector_resolver();
   init_runner();
+  init_manifest();
   init_auth();
   activityLog = [];
   MIME_TYPES = {
@@ -32402,8 +33219,8 @@ init_registry2();
 init_installer();
 import { render } from "ink";
 import chalk2 from "chalk";
-import { readdirSync as readdirSync8, statSync as statSync4 } from "fs";
-import { join as join13, relative as relative2 } from "path";
+import { readdirSync as readdirSync8, statSync as statSync5 } from "fs";
+import { join as join14, relative as relative2 } from "path";
 import { createInterface } from "readline";
 import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
 var isTTY = process.stdout.isTTY ?? false;
@@ -32418,8 +33235,8 @@ var PRESETS = {
 function listFilesRecursive(dir, base = dir) {
   const files = [];
   for (const entry of readdirSync8(dir)) {
-    const fullPath = join13(dir, entry);
-    if (statSync4(fullPath).isDirectory()) {
+    const fullPath = join14(dir, entry);
+    if (statSync5(fullPath).isDirectory()) {
       files.push(...listFilesRecursive(fullPath, base));
     } else {
       files.push(relative2(base, fullPath));
@@ -32468,9 +33285,9 @@ function registerCommands(program2) {
     }
     if (options.dryRun) {
       const installed = getInstalledConnectors();
-      const connectorsDir = join13(process.cwd(), ".connectors");
-      const manifestPath = join13(connectorsDir, "manifest.json");
-      const indexPath = join13(connectorsDir, "index.ts");
+      const connectorsDir = join14(process.cwd(), ".connectors");
+      const manifestPath = join14(connectorsDir, "manifest.json");
+      const indexPath = join14(connectorsDir, "index.ts");
       const actions = [];
       for (const name of connectors18) {
         if (!/^[a-z0-9-]+$/.test(name)) {
@@ -32486,7 +33303,6 @@ function registerCommands(program2) {
           actions.push({ connector: name, action: "error", reason: `Connector '${name}' source files not found` });
           continue;
         }
-        const connectorDirName = name.startsWith("connect-") ? name : `connect-${name}`;
         const sourcePath = getConnectorPath(name);
         const alreadyInstalled = installed.includes(name);
         const files = listFilesRecursive(sourcePath);
@@ -33088,8 +33904,9 @@ init_registry2();
 init_installer();
 init_auth();
 init_database();
+init_connector_resolver();
 import chalk4 from "chalk";
-import { existsSync as existsSync18, readdirSync as readdirSync12, statSync as statSync7, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync10 } from "fs";
 import { join as join19 } from "path";
 function registerCommands3(program2) {
   program2.command("status").option("--json", "Output as JSON", false).description("Show auth status of all configured connectors (project + global)").action((options) => {
@@ -33099,13 +33916,15 @@ function registerCommands3(program2) {
     const allStatuses = [];
     function buildStatusEntry(name, source) {
       const auth = getAuthStatus(name);
-      const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-      const currentProfileFile = join19(configDir, connectorName, "current_profile");
       let profile = "default";
-      if (existsSync18(currentProfileFile)) {
-        try {
-          profile = readFileSync9(currentProfileFile, "utf-8").trim() || "default";
-        } catch {}
+      for (const connectorConfigDir of getConnectorConfigReadDirs(name, configDir)) {
+        const currentProfileFile = join19(connectorConfigDir, "current_profile");
+        if (existsSync19(currentProfileFile)) {
+          try {
+            profile = readFileSync10(currentProfileFile, "utf-8").trim() || "default";
+          } catch {}
+          break;
+        }
       }
       let expiryLabel = null;
       let expired = false;
@@ -33140,21 +33959,11 @@ function registerCommands3(program2) {
       seen.add(name);
       allStatuses.push(buildStatusEntry(name, "project"));
     }
-    if (existsSync18(configDir)) {
+    if (existsSync19(configDir)) {
       try {
-        const globalDirs = readdirSync12(configDir).filter((f) => {
-          if (!f.startsWith("connect-"))
-            return false;
-          if (f.startsWith("connect-zzztest"))
-            return false;
-          try {
-            return statSync7(join19(configDir, f)).isDirectory();
-          } catch {
-            return false;
-          }
-        });
-        for (const dir of globalDirs) {
-          const name = dir.replace("connect-", "");
+        for (const name of listConfiguredConnectorNames(configDir)) {
+          if (name.startsWith("zzztest"))
+            continue;
           if (seen.has(name))
             continue;
           seen.add(name);
@@ -33361,10 +34170,11 @@ init_registry2();
 init_auth();
 init_database();
 import chalk5 from "chalk";
-import { existsSync as existsSync19, readdirSync as readdirSync13, statSync as statSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync12 } from "fs";
+import { existsSync as existsSync20, readdirSync as readdirSync12, statSync as statSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync9, mkdirSync as mkdirSync11 } from "fs";
 import { join as join20 } from "path";
 import { homedir as homedir8 } from "os";
 import { createInterface as createInterface2 } from "readline";
+init_connector_resolver();
 var SENSITIVE_FIELDS = new Set([
   "clientsecret",
   "client_secret",
@@ -33415,7 +34225,7 @@ function redactSecrets(obj) {
   return obj;
 }
 function getOAuthTokenState(name) {
-  const tokens = loadTokens2(name);
+  const tokens = loadTokens3(name);
   if (!tokens?.accessToken && !tokens?.refreshToken) {
     return { hasTokens: false, expired: false };
   }
@@ -33580,13 +34390,12 @@ ${meta.displayName} \u2014 Auth Configuration
 `);
           console.log(chalk5.dim("Waiting for authentication to complete..."));
           const connectorsHome = getConnectorsHome();
-          const connectorDirName = connector.startsWith("connect-") ? connector : `connect-${connector}`;
-          const tokensPath = join20(connectorsHome, connectorDirName, "profiles", "default", "tokens.json");
+          const tokenPaths = getConnectorConfigReadDirs(connector, connectorsHome).map((dir) => join20(dir, "profiles", "default", "tokens.json"));
           let attempts = 0;
           const maxAttempts = 360;
           while (attempts < maxAttempts) {
             await new Promise((resolve) => setTimeout(resolve, 500));
-            if (existsSync19(tokensPath)) {
+            if (tokenPaths.some((tokensPath) => existsSync20(tokensPath))) {
               break;
             }
             attempts++;
@@ -33600,7 +34409,7 @@ ${meta.displayName} \u2014 Auth Configuration
           if (attempts >= maxAttempts) {
             console.log();
             console.log(chalk5.yellow("Timed out waiting for OAuth callback. The auth may still be in progress."));
-            console.log(chalk5.dim(`Check ${tokensPath} for tokens.`));
+            console.log(chalk5.dim(`Check ${tokenPaths[0]} for tokens.`));
             console.log(chalk5.dim("You can stop the server manually: lsof -ti :${port} | xargs kill"));
             process.exit(1);
             return;
@@ -33733,13 +34542,12 @@ Open this URL to authenticate:
     let configuredCount = 0;
     const configuredNames = [];
     try {
-      if (existsSync19(connectorsHome)) {
-        const entries = readdirSync13(connectorsHome).filter((e) => e.startsWith("connect-") && statSync8(join20(connectorsHome, e)).isDirectory());
-        for (const entry of entries) {
-          const profilesDir = join20(connectorsHome, entry, "profiles");
-          if (existsSync19(profilesDir)) {
+      if (existsSync20(connectorsHome)) {
+        for (const name of listConfiguredConnectorNames(connectorsHome)) {
+          const hasProfiles = getConnectorConfigReadDirs(name, connectorsHome).some((dir) => existsSync20(join20(dir, "profiles")));
+          if (hasProfiles) {
             configuredCount++;
-            configuredNames.push(entry.replace(/^connect-/, ""));
+            configuredNames.push(name);
           }
         }
       }
@@ -33788,46 +34596,45 @@ Open this URL to authenticate:
   program2.command("export").option("-o, --output <file>", "Write to file instead of stdout").option("--include-secrets", "Include secrets in plaintext (dangerous \u2014 use only for backup/restore)").description("Export all connector credentials as JSON backup").action((options) => {
     const connectDir = getConnectorsHome();
     const result = {};
-    if (existsSync19(connectDir)) {
-      for (const entry of readdirSync13(connectDir)) {
-        const entryPath = join20(connectDir, entry);
-        if (!statSync8(entryPath).isDirectory() || !entry.startsWith("connect-"))
-          continue;
-        const connectorName = entry.replace(/^connect-/, "");
+    if (existsSync20(connectDir)) {
+      for (const connectorName of listConfiguredConnectorNames(connectDir)) {
+        const connectorDirs = [...getConnectorConfigReadDirs(connectorName, connectDir)].reverse();
         let credentials = undefined;
-        const credentialsPath = join20(entryPath, "credentials.json");
-        if (existsSync19(credentialsPath)) {
-          try {
-            credentials = JSON.parse(readFileSync10(credentialsPath, "utf-8"));
-          } catch {}
+        for (const connectorDir of connectorDirs) {
+          const credentialsPath = join20(connectorDir, "credentials.json");
+          if (existsSync20(credentialsPath)) {
+            try {
+              credentials = JSON.parse(readFileSync11(credentialsPath, "utf-8"));
+            } catch {}
+          }
         }
-        const profilesDir = join20(entryPath, "profiles");
-        if (!existsSync19(profilesDir) && !credentials)
-          continue;
         const profiles = {};
-        if (existsSync19(profilesDir)) {
-          for (const pEntry of readdirSync13(profilesDir)) {
-            const pPath = join20(profilesDir, pEntry);
-            if (statSync8(pPath).isFile() && pEntry.endsWith(".json")) {
-              try {
-                profiles[pEntry.replace(/\.json$/, "")] = JSON.parse(readFileSync10(pPath, "utf-8"));
-              } catch {}
-            } else if (statSync8(pPath).isDirectory()) {
-              const configPath = join20(pPath, "config.json");
-              const tokensPath = join20(pPath, "tokens.json");
-              let merged = {};
-              if (existsSync19(configPath)) {
+        for (const connectorDir of connectorDirs) {
+          const profilesDir = join20(connectorDir, "profiles");
+          if (existsSync20(profilesDir)) {
+            for (const pEntry of readdirSync12(profilesDir)) {
+              const pPath = join20(profilesDir, pEntry);
+              if (statSync8(pPath).isFile() && pEntry.endsWith(".json")) {
                 try {
-                  merged = { ...merged, ...JSON.parse(readFileSync10(configPath, "utf-8")) };
-                } catch {}
-              }
-              if (existsSync19(tokensPath)) {
-                try {
-                  merged = { ...merged, ...JSON.parse(readFileSync10(tokensPath, "utf-8")) };
+                  profiles[pEntry.replace(/\.json$/, "")] = JSON.parse(readFileSync11(pPath, "utf-8"));
                 } catch {}
+              } else if (statSync8(pPath).isDirectory()) {
+                const configPath = join20(pPath, "config.json");
+                const tokensPath = join20(pPath, "tokens.json");
+                let merged = {};
+                if (existsSync20(configPath)) {
+                  try {
+                    merged = { ...merged, ...JSON.parse(readFileSync11(configPath, "utf-8")) };
+                  } catch {}
+                }
+                if (existsSync20(tokensPath)) {
+                  try {
+                    merged = { ...merged, ...JSON.parse(readFileSync11(tokensPath, "utf-8")) };
+                  } catch {}
+                }
+                if (Object.keys(merged).length > 0)
+                  profiles[pEntry] = merged;
               }
-              if (Object.keys(merged).length > 0)
-                profiles[pEntry] = merged;
             }
           }
         }
@@ -33844,7 +34651,7 @@ Open this URL to authenticate:
     }
     const exportData = JSON.stringify(exportPayload, null, 2);
     if (options.output) {
-      writeFileSync8(options.output, exportData);
+      writeFileSync9(options.output, exportData);
       console.log(chalk5.green(`\u2713 Exported to ${options.output}`));
     } else {
       console.log(exportData);
@@ -33858,7 +34665,7 @@ Open this URL to authenticate:
         chunks.push(chunk.toString());
       raw = chunks.join("");
     } else {
-      if (!existsSync19(file)) {
+      if (!existsSync20(file)) {
         if (options.json) {
           console.log(JSON.stringify({ error: `File not found: ${file}` }));
         } else {
@@ -33867,7 +34674,7 @@ Open this URL to authenticate:
         process.exit(1);
         return;
       }
-      raw = readFileSync10(file, "utf-8");
+      raw = readFileSync11(file, "utf-8");
     }
     let data;
     try {
@@ -33895,10 +34702,10 @@ Open this URL to authenticate:
     for (const [connectorName, connData] of Object.entries(data.connectors)) {
       if (!/^[a-z0-9-]+$/.test(connectorName))
         continue;
-      const connectorDir = join20(connectDir, `connect-${connectorName}`);
+      const connectorDir = getConnectorConfigDir(connectorName, connectDir);
       if (connData.credentials && typeof connData.credentials === "object") {
-        mkdirSync12(connectorDir, { recursive: true });
-        writeFileSync8(join20(connectorDir, "credentials.json"), JSON.stringify(connData.credentials, null, 2));
+        mkdirSync11(connectorDir, { recursive: true });
+        writeFileSync9(join20(connectorDir, "credentials.json"), JSON.stringify(connData.credentials, null, 2));
         imported++;
       }
       if (!connData.profiles || typeof connData.profiles !== "object")
@@ -33907,8 +34714,8 @@ Open this URL to authenticate:
       for (const [profileName, config] of Object.entries(connData.profiles)) {
         if (!config || typeof config !== "object")
           continue;
-        mkdirSync12(profilesDir, { recursive: true });
-        writeFileSync8(join20(profilesDir, `${profileName}.json`), JSON.stringify(config, null, 2));
+        mkdirSync11(profilesDir, { recursive: true });
+        writeFileSync9(join20(profilesDir, `${profileName}.json`), JSON.stringify(config, null, 2));
         imported++;
       }
     }
@@ -33921,7 +34728,7 @@ Open this URL to authenticate:
   program2.command("auth-import").option("--json", "Output as JSON", false).option("-d, --dry-run", "Preview what would be imported without copying", false).option("--force", "Overwrite existing files in ~/.hasna/connectors/", false).description("Migrate auth tokens from ~/.connect/ to ~/.hasna/connectors/").action((options) => {
     const oldBase = join20(homedir8(), ".connect");
     const newBase = getConnectorsHome();
-    if (!existsSync19(oldBase)) {
+    if (!existsSync20(oldBase)) {
       if (options.json) {
         console.log(JSON.stringify({ imported: [], skipped: [], error: null, message: "No ~/.connect/ directory found" }));
       } else {
@@ -33929,7 +34736,7 @@ Open this URL to authenticate:
       }
       return;
     }
-    const entries = readdirSync13(oldBase).filter((name) => {
+    const entries = readdirSync12(oldBase).filter((name) => {
       if (!name.startsWith("connect-"))
         return false;
       try {
@@ -33950,8 +34757,8 @@ Open this URL to authenticate:
     const skipped = [];
     for (const dirName of entries) {
       const oldDir = join20(oldBase, dirName);
-      const newDir = join20(newBase, dirName);
       const connectorName = dirName.replace(/^connect-/, "");
+      const newDir = getConnectorConfigDir(connectorName, newBase);
       const allFiles = listFilesRecursive(oldDir);
       const authFiles = allFiles.filter((f) => {
         return f === "credentials.json" || f === "config.json" || f === "tokens.json" || f === "current_profile" || f.startsWith("profiles/") || f.startsWith("profiles\\");
@@ -33963,15 +34770,15 @@ Open this URL to authenticate:
       for (const relFile of authFiles) {
         const srcPath = join20(oldDir, relFile);
         const destPath = join20(newDir, relFile);
-        if (existsSync19(destPath) && !options.force) {
+        if (existsSync20(destPath) && !options.force) {
           skippedFiles.push(relFile);
           continue;
         }
         if (!options.dryRun) {
           const parentDir = join20(destPath, "..");
-          mkdirSync12(parentDir, { recursive: true });
-          const content = readFileSync10(srcPath);
-          writeFileSync8(destPath, content);
+          mkdirSync11(parentDir, { recursive: true });
+          const content = readFileSync11(srcPath);
+          writeFileSync9(destPath, content);
         }
         copiedFiles.push(relFile);
       }
@@ -34037,7 +34844,7 @@ init_installer();
 init_auth();
 init_database();
 import chalk6 from "chalk";
-import { existsSync as existsSync20, readdirSync as readdirSync14, statSync as statSync9, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
 import { join as join21 } from "path";
 
 // src/lib/test-endpoints.ts
@@ -34237,6 +35044,7 @@ var TEST_ENDPOINTS = {
 
 // src/cli/commands/misc.ts
 init_auth();
+init_connector_resolver();
 function registerCommands5(program2) {
   program2.command("upgrade").alias("self-update").option("--check", "Only check for updates, don't install", false).option("--json", "Output as JSON", false).description("Check for updates and upgrade to the latest version").action(async (options) => {
     const currentVersion = program2.version();
@@ -34425,7 +35233,7 @@ complete -F _connectors connectors`);
 `) + `
 `;
     if (options.output) {
-      writeFileSync9(options.output, output);
+      writeFileSync10(options.output, output);
       console.log(chalk6.green(`\u2713 Written to ${options.output} (${vars.length} variables)`));
     } else {
       console.log(output);
@@ -34467,29 +35275,21 @@ Available presets:
         configured++;
       else
         unconfigured++;
-      const connectorConfigDir = join21(configDir, name.startsWith("connect-") ? name : `connect-${name}`);
-      const currentProfileFile = join21(connectorConfigDir, "current_profile");
       let profile = "default";
-      if (existsSync20(currentProfileFile)) {
-        try {
-          profile = readFileSync11(currentProfileFile, "utf-8").trim() || "default";
-        } catch {}
+      for (const connectorConfigDir of getConnectorConfigReadDirs(name, configDir)) {
+        const currentProfileFile = join21(connectorConfigDir, "current_profile");
+        if (existsSync21(currentProfileFile)) {
+          try {
+            profile = readFileSync12(currentProfileFile, "utf-8").trim() || "default";
+          } catch {}
+          break;
+        }
       }
       connectorDetails.push({ name, configured: auth.configured, authType: auth.type, profile, source: "project" });
     }
-    if (existsSync20(configDir)) {
+    if (existsSync21(configDir)) {
       try {
-        const globalDirs = readdirSync14(configDir).filter((f) => {
-          if (!f.startsWith("connect-"))
-            return false;
-          try {
-            return statSync9(join21(configDir, f)).isDirectory();
-          } catch {
-            return false;
-          }
-        });
-        for (const dir of globalDirs) {
-          const name = dir.replace("connect-", "");
+        for (const name of listConfiguredConnectorNames(configDir)) {
           if (seen.has(name))
             continue;
           const auth = getAuthStatus(name);
@@ -34497,12 +35297,15 @@ Available presets:
             continue;
           seen.add(name);
           configured++;
-          const currentProfileFile = join21(configDir, dir, "current_profile");
           let profile = "default";
-          if (existsSync20(currentProfileFile)) {
-            try {
-              profile = readFileSync11(currentProfileFile, "utf-8").trim() || "default";
-            } catch {}
+          for (const connectorConfigDir of getConnectorConfigReadDirs(name, configDir)) {
+            const currentProfileFile = join21(connectorConfigDir, "current_profile");
+            if (existsSync21(currentProfileFile)) {
+              try {
+                profile = readFileSync12(currentProfileFile, "utf-8").trim() || "default";
+              } catch {}
+              break;
+            }
           }
           connectorDetails.push({ name, configured: true, authType: auth.type, profile, source: "global" });
         }
@@ -34512,7 +35315,7 @@ Available presets:
       console.log(JSON.stringify({
         version,
         configDir,
-        configDirExists: existsSync20(configDir),
+        configDirExists: existsSync21(configDir),
         installed: installed.length,
         configured,
         unconfigured,
@@ -34524,7 +35327,7 @@ Available presets:
 Connectors Setup
 `));
     console.log(`  Version:      ${chalk6.cyan(version)}`);
-    console.log(`  Config:       ${configDir}${existsSync20(configDir) ? "" : chalk6.dim(" (not created yet)")}`);
+    console.log(`  Config:       ${configDir}${existsSync21(configDir) ? "" : chalk6.dim(" (not created yet)")}`);
     console.log(`  Installed:    ${installed.length} connector${installed.length !== 1 ? "s" : ""}`);
     console.log(`  Configured:   ${chalk6.green(String(configured))} ready, ${unconfigured > 0 ? chalk6.red(String(unconfigured)) : chalk6.dim("0")} need auth`);
     const projectConnectors = connectorDetails.filter((c) => c.source === "project");
@@ -34615,18 +35418,21 @@ Testing connector credentials...
         }
       }
       if (!apiKey) {
-        const connectorConfigDir = join21(getConnectorsHome(), name.startsWith("connect-") ? name : `connect-${name}`);
+        const connectorConfigDirs = getConnectorConfigReadDirs(name);
         let currentProfile = "default";
-        const currentProfileFile = join21(connectorConfigDir, "current_profile");
-        if (existsSync20(currentProfileFile)) {
-          try {
-            currentProfile = readFileSync11(currentProfileFile, "utf-8").trim() || "default";
-          } catch {}
+        for (const connectorConfigDir of connectorConfigDirs) {
+          const currentProfileFile = join21(connectorConfigDir, "current_profile");
+          if (existsSync21(currentProfileFile)) {
+            try {
+              currentProfile = readFileSync12(currentProfileFile, "utf-8").trim() || "default";
+            } catch {}
+            break;
+          }
         }
-        const tokensFile = join21(connectorConfigDir, "profiles", currentProfile, "tokens.json");
-        if (existsSync20(tokensFile)) {
+        const tokensFile = connectorConfigDirs.map((dir) => join21(dir, "profiles", currentProfile, "tokens.json")).find((path) => existsSync21(path));
+        if (tokensFile) {
           try {
-            const tokens = JSON.parse(readFileSync11(tokensFile, "utf-8"));
+            const tokens = JSON.parse(readFileSync12(tokensFile, "utf-8"));
             const isExpired = tokens.expiresAt && Date.now() >= tokens.expiresAt - 60000;
             if (isExpired && tokens.refreshToken) {
               try {
@@ -34644,21 +35450,29 @@ Testing connector credentials...
           } catch {}
         }
         if (!apiKey) {
-          const profileFile = join21(connectorConfigDir, "profiles", `${currentProfile}.json`);
-          if (existsSync20(profileFile)) {
-            try {
-              const config = JSON.parse(readFileSync11(profileFile, "utf-8"));
-              apiKey = Object.values(config).find((v) => typeof v === "string" && v.length > 0);
-            } catch {}
+          for (const connectorConfigDir of connectorConfigDirs) {
+            const profileFile = join21(connectorConfigDir, "profiles", `${currentProfile}.json`);
+            if (existsSync21(profileFile)) {
+              try {
+                const config = JSON.parse(readFileSync12(profileFile, "utf-8"));
+                apiKey = Object.values(config).find((v) => typeof v === "string" && v.length > 0);
+              } catch {}
+              if (apiKey)
+                break;
+            }
           }
         }
         if (!apiKey) {
-          const profileDirConfig = join21(connectorConfigDir, "profiles", currentProfile, "config.json");
-          if (existsSync20(profileDirConfig)) {
-            try {
-              const config = JSON.parse(readFileSync11(profileDirConfig, "utf-8"));
-              apiKey = Object.values(config).find((v) => typeof v === "string" && v.length > 0);
-            } catch {}
+          for (const connectorConfigDir of connectorConfigDirs) {
+            const profileDirConfig = join21(connectorConfigDir, "profiles", currentProfile, "config.json");
+            if (existsSync21(profileDirConfig)) {
+              try {
+                const config = JSON.parse(readFileSync12(profileDirConfig, "utf-8"));
+                apiKey = Object.values(config).find((v) => typeof v === "string" && v.length > 0);
+              } catch {}
+              if (apiKey)
+                break;
+            }
           }
         }
       }
@@ -34735,6 +35549,7 @@ Testing connector credentials...
 init_registry2();
 init_auth();
 init_runner();
+init_connector_resolver();
 import chalk7 from "chalk";
 function registerCommands6(program2) {
   program2.command("ops").description("List available API operations for a connector").argument("<name>", "Connector name (e.g. stripe, gmail)").argument("[command]", "Get detailed help for a specific subcommand").option("--json", "Output as JSON").action(async (name, command, options) => {
@@ -34916,13 +35731,12 @@ Setting up ${meta.displayName}...
             }
             console.log(chalk7.dim("  Waiting for authentication to complete..."));
             const connectorsHome = getConnectorsHome2();
-            const connectorDirName = name.startsWith("connect-") ? name : `connect-${name}`;
-            const tokensPath = join8(connectorsHome, connectorDirName, "profiles", "default", "tokens.json");
+            const tokenPaths = getConnectorConfigReadDirs(name, connectorsHome).map((dir) => join8(dir, "profiles", "default", "tokens.json"));
             let attempts = 0;
             const maxAttempts = 360;
             while (attempts < maxAttempts) {
               await new Promise((resolve) => setTimeout(resolve, 500));
-              if (existsSync8(tokensPath))
+              if (tokenPaths.some((tokensPath) => existsSync8(tokensPath)))
                 break;
               attempts++;
               if (attempts % 6 === 0)