@hasna/connectors 1.2.1 → 1.3.1

package/bin/mcp.js

@@ -6500,6 +6500,187 @@ var require_dist = __commonJS((exports, module) => {
   exports.default = formatsPlugin;
 });
 
+// src/lib/installer.ts
+var exports_installer = {};
+__export(exports_installer, {
+  removeConnector: () => removeConnector,
+  installConnectors: () => installConnectors,
+  installConnector: () => installConnector,
+  getInstalledConnectors: () => getInstalledConnectors,
+  getConnectorPath: () => getConnectorPath,
+  getConnectorDocs: () => getConnectorDocs,
+  connectorExists: () => connectorExists
+});
+import { existsSync as existsSync2, cpSync, mkdirSync, readFileSync as readFileSync2, writeFileSync, readdirSync, statSync, rmSync } from "fs";
+import { homedir } from "os";
+import { join as join2, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function resolveConnectorsDir() {
+  const fromBin = join2(__dirname2, "..", "connectors");
+  if (existsSync2(fromBin))
+    return fromBin;
+  const fromSrc = join2(__dirname2, "..", "..", "connectors");
+  if (existsSync2(fromSrc))
+    return fromSrc;
+  return fromBin;
+}
+function getConnectorPath(name) {
+  const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
+  return join2(CONNECTORS_DIR, connectorName);
+}
+function connectorExists(name) {
+  return existsSync2(getConnectorPath(name));
+}
+function installConnector(name, options = {}) {
+  const { targetDir = process.cwd(), overwrite = false } = options;
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    return {
+      connector: name,
+      success: false,
+      error: `Invalid connector name '${name}'`
+    };
+  }
+  const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
+  const sourcePath = getConnectorPath(name);
+  const destDir = join2(targetDir, ".connectors");
+  const destPath = join2(destDir, connectorName);
+  if (!existsSync2(sourcePath)) {
+    return {
+      connector: name,
+      success: false,
+      error: `Connector '${name}' not found`
+    };
+  }
+  if (existsSync2(destPath) && !overwrite) {
+    return {
+      connector: name,
+      success: false,
+      error: `Already installed. Use --overwrite to replace.`,
+      path: destPath
+    };
+  }
+  try {
+    if (!existsSync2(destDir)) {
+      mkdirSync(destDir, { recursive: true });
+    }
+    cpSync(sourcePath, destPath, { recursive: true });
+    const homeCredDir = join2(homedir(), ".connectors", connectorName);
+    if (existsSync2(homeCredDir)) {
+      const filesToCopy = ["credentials.json", "current_profile"];
+      for (const file of filesToCopy) {
+        const src = join2(homeCredDir, file);
+        if (existsSync2(src)) {
+          cpSync(src, join2(destPath, file));
+        }
+      }
+      const profilesDir = join2(homeCredDir, "profiles");
+      if (existsSync2(profilesDir)) {
+        cpSync(profilesDir, join2(destPath, "profiles"), { recursive: true });
+      }
+    }
+    updateConnectorsIndex(destDir);
+    return {
+      connector: name,
+      success: true,
+      path: destPath
+    };
+  } catch (error2) {
+    return {
+      connector: name,
+      success: false,
+      error: error2 instanceof Error ? error2.message : "Unknown error"
+    };
+  }
+}
+function installConnectors(names, options = {}) {
+  return names.map((name) => installConnector(name, options));
+}
+function updateConnectorsIndex(connectorsDir) {
+  const indexPath = join2(connectorsDir, "index.ts");
+  const connectors = readdirSync(connectorsDir).filter((f) => f.startsWith("connect-") && !f.includes("."));
+  const exports = connectors.map((c) => {
+    const name = c.replace("connect-", "");
+    return `export * as ${name} from './${c}/src/index.js';`;
+  }).join(`
+`);
+  const content = `/**
+ * Auto-generated index of installed connectors
+ * Do not edit manually - run 'connectors install' to update
+ */
+
+${exports}
+`;
+  writeFileSync(indexPath, content);
+}
+function getInstalledConnectors(targetDir = process.cwd()) {
+  const connectorsDir = join2(targetDir, ".connectors");
+  if (!existsSync2(connectorsDir)) {
+    return [];
+  }
+  return readdirSync(connectorsDir).filter((f) => {
+    const fullPath = join2(connectorsDir, f);
+    return f.startsWith("connect-") && statSync(fullPath).isDirectory();
+  }).map((f) => f.replace("connect-", ""));
+}
+function getConnectorDocs(name) {
+  const connectorPath = getConnectorPath(name);
+  const claudeMdPath = join2(connectorPath, "CLAUDE.md");
+  if (!existsSync2(claudeMdPath))
+    return null;
+  const raw = readFileSync2(claudeMdPath, "utf-8");
+  return {
+    overview: extractSection(raw, "Project Overview"),
+    auth: extractSection(raw, "Authentication"),
+    envVars: parseEnvVarsTable(extractSection(raw, "Environment Variables")),
+    cliCommands: extractSection(raw, "CLI Commands"),
+    dataStorage: extractSection(raw, "Data Storage"),
+    raw
+  };
+}
+function extractSection(markdown, heading) {
+  const regex = new RegExp(`^##\\s+${escapeRegex2(heading)}\\s*$`, "m");
+  const match = regex.exec(markdown);
+  if (!match)
+    return "";
+  const start = match.index + match[0].length;
+  const nextHeading = markdown.slice(start).search(/^##\s/m);
+  const content = nextHeading === -1 ? markdown.slice(start) : markdown.slice(start, start + nextHeading);
+  return content.trim();
+}
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseEnvVarsTable(section) {
+  if (!section)
+    return [];
+  const vars = [];
+  const lines = section.split(`
+`);
+  for (const line of lines) {
+    const match = line.match(/\|\s*`([^`]+)`\s*\|\s*(.+?)\s*\|/);
+    if (match && match[1] !== "Variable") {
+      vars.push({ variable: match[1], description: match[2].trim() });
+    }
+  }
+  return vars;
+}
+function removeConnector(name, targetDir = process.cwd()) {
+  const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
+  const connectorsDir = join2(targetDir, ".connectors");
+  const connectorPath = join2(connectorsDir, connectorName);
+  if (!existsSync2(connectorPath)) {
+    return false;
+  }
+  rmSync(connectorPath, { recursive: true });
+  updateConnectorsIndex(connectorsDir);
+  return true;
+}
+var __dirname2, CONNECTORS_DIR;
+var init_installer = __esm(() => {
+  __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+  CONNECTORS_DIR = resolveConnectorsDir();
+});
+
 // src/db/database.ts
 var exports_database = {};
 __export(exports_database, {
@@ -6607,6 +6788,22 @@ function migrate(db) {
       created_at TEXT NOT NULL
     )
   `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_usage (
+      id TEXT PRIMARY KEY,
+      connector TEXT NOT NULL,
+      action TEXT NOT NULL,
+      agent_id TEXT,
+      timestamp TEXT NOT NULL
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_usage_connector ON connector_usage(connector, timestamp DESC)`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_promotions (
+      connector TEXT UNIQUE NOT NULL,
+      promoted_at TEXT NOT NULL
+    )
+  `);
 }
 var DB_DIR, DB_PATH, _db = null;
 var init_database = __esm(() => {
@@ -6781,6 +6978,75 @@ var init_strip = __esm(() => {
   init_llm();
 });
 
+// src/db/promotions.ts
+var exports_promotions = {};
+__export(exports_promotions, {
+  promoteConnector: () => promoteConnector,
+  isPromoted: () => isPromoted,
+  getPromotedConnectors: () => getPromotedConnectors,
+  demoteConnector: () => demoteConnector
+});
+function promoteConnector(name, db) {
+  const d = db ?? getDatabase();
+  d.run("INSERT OR REPLACE INTO connector_promotions (connector, promoted_at) VALUES (?, ?)", [name, now()]);
+}
+function demoteConnector(name, db) {
+  const d = db ?? getDatabase();
+  return d.run("DELETE FROM connector_promotions WHERE connector = ?", [name]).changes > 0;
+}
+function getPromotedConnectors(db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT connector FROM connector_promotions ORDER BY promoted_at DESC").all().map((r) => r.connector);
+}
+function isPromoted(name, db) {
+  const d = db ?? getDatabase();
+  const row = d.query("SELECT 1 FROM connector_promotions WHERE connector = ?").get(name);
+  return !!row;
+}
+var init_promotions = __esm(() => {
+  init_database();
+});
+
+// src/db/usage.ts
+var exports_usage = {};
+__export(exports_usage, {
+  logUsage: () => logUsage,
+  getUsageStats: () => getUsageStats,
+  getUsageMap: () => getUsageMap,
+  getTopConnectors: () => getTopConnectors,
+  cleanOldUsage: () => cleanOldUsage
+});
+function logUsage(connector, action, agentId, db) {
+  const d = db ?? getDatabase();
+  d.run("INSERT INTO connector_usage (id, connector, action, agent_id, timestamp) VALUES (?, ?, ?, ?, ?)", [shortUuid(), connector, action, agentId ?? null, now()]);
+}
+function getUsageStats(connector, db) {
+  const d = db ?? getDatabase();
+  const total = d.query("SELECT COUNT(*) as c FROM connector_usage WHERE connector = ?").get(connector).c;
+  const d7 = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+  const last7d = d.query("SELECT COUNT(*) as c FROM connector_usage WHERE connector = ? AND timestamp > ?").get(connector, d7).c;
+  const d1 = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+  const last24h = d.query("SELECT COUNT(*) as c FROM connector_usage WHERE connector = ? AND timestamp > ?").get(connector, d1).c;
+  return { connector, total, last7d, last24h };
+}
+function getTopConnectors(limit = 10, days = 7, db) {
+  const d = db ?? getDatabase();
+  const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+  return d.query("SELECT connector, COUNT(*) as count FROM connector_usage WHERE timestamp > ? GROUP BY connector ORDER BY count DESC LIMIT ?").all(since, limit);
+}
+function getUsageMap(days = 7, db) {
+  const top = getTopConnectors(100, days, db);
+  return new Map(top.map((t) => [t.connector, t.count]));
+}
+function cleanOldUsage(days = 30, db) {
+  const d = db ?? getDatabase();
+  const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+  return d.run("DELETE FROM connector_usage WHERE timestamp < ?", [cutoff]).changes;
+}
+var init_usage = __esm(() => {
+  init_database();
+});
+
 // src/db/jobs.ts
 var exports_jobs = {};
 __export(exports_jobs, {
@@ -20083,6 +20349,94 @@ class StdioServerTransport {
 import { existsSync, readFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
+
+// src/lib/fuzzy.ts
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0)
+    return n;
+  if (n === 0)
+    return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0;j <= n; j++)
+    prev[j] = j;
+  for (let i = 1;i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1;j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
+function bestFuzzyScore(token, candidates, maxDistance = 2) {
+  if (token.length < 3)
+    return 0;
+  let bestDist = maxDistance + 1;
+  for (const c of candidates) {
+    if (Math.abs(token.length - c.length) > maxDistance)
+      continue;
+    const d = levenshtein(token, c);
+    if (d < bestDist)
+      bestDist = d;
+    if (d === 0)
+      return maxDistance + 1;
+  }
+  if (bestDist > maxDistance)
+    return 0;
+  return maxDistance - bestDist + 1;
+}
+
+// src/lib/synonyms.ts
+var SYNONYM_MAP = {
+  email: ["smtp", "mail", "inbox", "resend", "ses"],
+  chat: ["messaging", "im", "slack", "discord", "teams"],
+  sms: ["text", "twilio", "messaging"],
+  payment: ["billing", "invoicing", "commerce", "checkout", "stripe"],
+  payments: ["billing", "invoicing", "commerce", "checkout", "stripe"],
+  ecommerce: ["shop", "store", "commerce", "shopify"],
+  finance: ["banking", "accounting", "invoicing"],
+  crypto: ["blockchain", "web3", "wallet"],
+  ai: ["llm", "ml", "model", "gpt", "claude", "anthropic", "openai"],
+  llm: ["ai", "model", "gpt", "claude"],
+  auth: ["oauth", "sso", "login", "identity", "authentication"],
+  database: ["db", "sql", "nosql", "postgres", "mongo", "supabase"],
+  deploy: ["hosting", "infrastructure", "ci", "cd", "vercel"],
+  storage: ["files", "drive", "s3", "bucket", "upload"],
+  cloud: ["aws", "gcp", "azure", "infrastructure"],
+  api: ["rest", "graphql", "endpoint", "webhook"],
+  monitoring: ["logs", "observability", "alerting", "datadog", "sentry"],
+  ci: ["cd", "deploy", "pipeline", "github", "actions"],
+  crm: ["sales", "leads", "contacts", "hubspot", "salesforce"],
+  analytics: ["data", "metrics", "tracking", "mixpanel", "amplitude"],
+  project: ["task", "issue", "board", "jira", "linear", "asana"],
+  docs: ["documentation", "wiki", "notion", "confluence"],
+  design: ["figma", "sketch", "ui", "ux"],
+  security: ["auth", "encryption", "compliance", "vault"]
+};
+function expandQuery(tokens) {
+  const synonyms = new Set;
+  for (const token of tokens) {
+    const matches = SYNONYM_MAP[token];
+    if (matches) {
+      for (const syn of matches) {
+        if (!tokens.includes(syn))
+          synonyms.add(syn);
+      }
+    }
+    for (const [key, values] of Object.entries(SYNONYM_MAP)) {
+      if (values.includes(token) && !tokens.includes(key)) {
+        synonyms.add(key);
+      }
+    }
+  }
+  return { original: tokens, expanded: [...synonyms] };
+}
+
+// src/lib/registry.ts
 var CATEGORIES = [
   "AI & ML",
   "Developer Tools",
@@ -26001,9 +26355,152 @@ var CONNECTORS = [
 function getConnectorsByCategory(category) {
   return CONNECTORS.filter((c) => c.category === category);
 }
-function searchConnectors(query) {
-  const q = query.toLowerCase();
-  return CONNECTORS.filter((c) => c.name.toLowerCase().includes(q) || c.displayName.toLowerCase().includes(q) || c.description.toLowerCase().includes(q) || c.tags.some((t) => t.includes(q)));
+function searchConnectors(query, context) {
+  const tokens = query.toLowerCase().trim().split(/\s+/).filter(Boolean);
+  if (tokens.length === 0)
+    return [];
+  const limit = context?.limit ?? 20;
+  const installed = new Set(context?.installed ?? []);
+  const promoted = new Set(context?.promoted ?? []);
+  const usage = context?.usage ?? new Map;
+  const results = [];
+  for (const c of CONNECTORS) {
+    const nameLow = c.name.toLowerCase();
+    const displayLow = c.displayName.toLowerCase();
+    const descLow = c.description.toLowerCase();
+    const tagsLow = c.tags.map((t) => t.toLowerCase());
+    let score = 0;
+    const matchReasons = [];
+    let allTokensMatch = true;
+    for (const token of tokens) {
+      let tokenMatched = false;
+      if (nameLow === token) {
+        score += 100;
+        matchReasons.push(`name="${token}"`);
+        tokenMatched = true;
+      } else if (nameLow.includes(token)) {
+        score += 10;
+        matchReasons.push(`name~${token}`);
+        tokenMatched = true;
+      }
+      if (tagsLow.includes(token)) {
+        score += 8;
+        if (!tokenMatched)
+          matchReasons.push(`tag="${token}"`);
+        tokenMatched = true;
+      } else if (tagsLow.some((t) => t.includes(token))) {
+        score += 5;
+        if (!tokenMatched)
+          matchReasons.push(`tag~${token}`);
+        tokenMatched = true;
+      }
+      if (displayLow.includes(token)) {
+        score += 3;
+        if (!tokenMatched)
+          matchReasons.push(`display~${token}`);
+        tokenMatched = true;
+      }
+      if (descLow.includes(token)) {
+        score += 1;
+        if (!tokenMatched)
+          matchReasons.push(`desc~${token}`);
+        tokenMatched = true;
+      }
+      if (!tokenMatched && token.length >= 3) {
+        const nameFuzzy = bestFuzzyScore(token, [nameLow], 1);
+        if (nameFuzzy > 0) {
+          score += nameFuzzy * 6;
+          matchReasons.push(`fuzzy:name\u2248${token}`);
+          tokenMatched = true;
+        }
+        if (!tokenMatched) {
+          const tagFuzzy = bestFuzzyScore(token, tagsLow, 2);
+          if (tagFuzzy > 0) {
+            score += tagFuzzy * 3;
+            matchReasons.push(`fuzzy:tag\u2248${token}`);
+            tokenMatched = true;
+          }
+        }
+        if (!tokenMatched) {
+          const displayFuzzy = bestFuzzyScore(token, [displayLow], 2);
+          if (displayFuzzy > 0) {
+            score += displayFuzzy * 2;
+            matchReasons.push(`fuzzy:display\u2248${token}`);
+            tokenMatched = true;
+          }
+        }
+      }
+      if (!tokenMatched) {
+        allTokensMatch = false;
+        break;
+      }
+    }
+    if (!allTokensMatch)
+      continue;
+    const badges = [];
+    if (installed.has(c.name)) {
+      score += 50;
+      badges.push("installed");
+    }
+    if (promoted.has(c.name)) {
+      score += 30;
+      badges.push("promoted");
+    }
+    const usageCount = usage.get(c.name) ?? 0;
+    if (usageCount > 0) {
+      score += Math.min(usageCount * 2, 40);
+      if (usageCount >= 5)
+        badges.push("hot");
+    }
+    results.push({ ...c, score, matchReasons, badges });
+  }
+  const matchedNames = new Set(results.map((r) => r.name));
+  if (results.length < limit) {
+    const { expanded } = expandQuery(tokens);
+    if (expanded.length > 0) {
+      for (const c of CONNECTORS) {
+        if (matchedNames.has(c.name))
+          continue;
+        const nameLow2 = c.name.toLowerCase();
+        const tagsLow2 = c.tags.map((t) => t.toLowerCase());
+        const descLow2 = c.description.toLowerCase();
+        let synScore = 0;
+        const synReasons = [];
+        for (const syn of expanded) {
+          if (nameLow2.includes(syn)) {
+            synScore += 2;
+            synReasons.push(`syn:name~${syn}`);
+          } else if (tagsLow2.some((t) => t.includes(syn))) {
+            synScore += 1;
+            synReasons.push(`syn:tag~${syn}`);
+          } else if (descLow2.includes(syn)) {
+            synScore += 1;
+            synReasons.push(`syn:desc~${syn}`);
+          }
+        }
+        if (synScore > 0) {
+          const badges = [];
+          if (installed.has(c.name)) {
+            synScore += 50;
+            badges.push("installed");
+          }
+          if (promoted.has(c.name)) {
+            synScore += 30;
+            badges.push("promoted");
+          }
+          const usageCount = usage.get(c.name) ?? 0;
+          if (usageCount > 0) {
+            synScore += Math.min(usageCount * 2, 40);
+            if (usageCount >= 5)
+              badges.push("hot");
+          }
+          results.push({ ...c, score: synScore, matchReasons: synReasons, badges });
+        }
+      }
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, limit);
 }
 function getConnector(name) {
   return CONNECTORS.find((c) => c.name === name);
@@ -26032,170 +26529,12 @@ function loadConnectorVersions() {
   }
 }
 
-// src/lib/installer.ts
-import { existsSync as existsSync2, cpSync, mkdirSync, readFileSync as readFileSync2, writeFileSync, readdirSync, statSync, rmSync } from "fs";
-import { homedir } from "os";
-import { join as join2, dirname as dirname2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
-function resolveConnectorsDir() {
-  const fromBin = join2(__dirname2, "..", "connectors");
-  if (existsSync2(fromBin))
-    return fromBin;
-  const fromSrc = join2(__dirname2, "..", "..", "connectors");
-  if (existsSync2(fromSrc))
-    return fromSrc;
-  return fromBin;
-}
-var CONNECTORS_DIR = resolveConnectorsDir();
-function getConnectorPath(name) {
-  const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  return join2(CONNECTORS_DIR, connectorName);
-}
-function installConnector(name, options = {}) {
-  const { targetDir = process.cwd(), overwrite = false } = options;
-  if (!/^[a-z0-9-]+$/.test(name)) {
-    return {
-      connector: name,
-      success: false,
-      error: `Invalid connector name '${name}'`
-    };
-  }
-  const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  const sourcePath = getConnectorPath(name);
-  const destDir = join2(targetDir, ".connectors");
-  const destPath = join2(destDir, connectorName);
-  if (!existsSync2(sourcePath)) {
-    return {
-      connector: name,
-      success: false,
-      error: `Connector '${name}' not found`
-    };
-  }
-  if (existsSync2(destPath) && !overwrite) {
-    return {
-      connector: name,
-      success: false,
-      error: `Already installed. Use --overwrite to replace.`,
-      path: destPath
-    };
-  }
-  try {
-    if (!existsSync2(destDir)) {
-      mkdirSync(destDir, { recursive: true });
-    }
-    cpSync(sourcePath, destPath, { recursive: true });
-    const homeCredDir = join2(homedir(), ".connectors", connectorName);
-    if (existsSync2(homeCredDir)) {
-      const filesToCopy = ["credentials.json", "current_profile"];
-      for (const file of filesToCopy) {
-        const src = join2(homeCredDir, file);
-        if (existsSync2(src)) {
-          cpSync(src, join2(destPath, file));
-        }
-      }
-      const profilesDir = join2(homeCredDir, "profiles");
-      if (existsSync2(profilesDir)) {
-        cpSync(profilesDir, join2(destPath, "profiles"), { recursive: true });
-      }
-    }
-    updateConnectorsIndex(destDir);
-    return {
-      connector: name,
-      success: true,
-      path: destPath
-    };
-  } catch (error2) {
-    return {
-      connector: name,
-      success: false,
-      error: error2 instanceof Error ? error2.message : "Unknown error"
-    };
-  }
-}
-function updateConnectorsIndex(connectorsDir) {
-  const indexPath = join2(connectorsDir, "index.ts");
-  const connectors = readdirSync(connectorsDir).filter((f) => f.startsWith("connect-") && !f.includes("."));
-  const exports = connectors.map((c) => {
-    const name = c.replace("connect-", "");
-    return `export * as ${name} from './${c}/src/index.js';`;
-  }).join(`
-`);
-  const content = `/**
- * Auto-generated index of installed connectors
- * Do not edit manually - run 'connectors install' to update
- */
-
-${exports}
-`;
-  writeFileSync(indexPath, content);
-}
-function getInstalledConnectors(targetDir = process.cwd()) {
-  const connectorsDir = join2(targetDir, ".connectors");
-  if (!existsSync2(connectorsDir)) {
-    return [];
-  }
-  return readdirSync(connectorsDir).filter((f) => {
-    const fullPath = join2(connectorsDir, f);
-    return f.startsWith("connect-") && statSync(fullPath).isDirectory();
-  }).map((f) => f.replace("connect-", ""));
-}
-function getConnectorDocs(name) {
-  const connectorPath = getConnectorPath(name);
-  const claudeMdPath = join2(connectorPath, "CLAUDE.md");
-  if (!existsSync2(claudeMdPath))
-    return null;
-  const raw = readFileSync2(claudeMdPath, "utf-8");
-  return {
-    overview: extractSection(raw, "Project Overview"),
-    auth: extractSection(raw, "Authentication"),
-    envVars: parseEnvVarsTable(extractSection(raw, "Environment Variables")),
-    cliCommands: extractSection(raw, "CLI Commands"),
-    dataStorage: extractSection(raw, "Data Storage"),
-    raw
-  };
-}
-function extractSection(markdown, heading) {
-  const regex = new RegExp(`^##\\s+${escapeRegex2(heading)}\\s*$`, "m");
-  const match = regex.exec(markdown);
-  if (!match)
-    return "";
-  const start = match.index + match[0].length;
-  const nextHeading = markdown.slice(start).search(/^##\s/m);
-  const content = nextHeading === -1 ? markdown.slice(start) : markdown.slice(start, start + nextHeading);
-  return content.trim();
-}
-function escapeRegex2(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function parseEnvVarsTable(section) {
-  if (!section)
-    return [];
-  const vars = [];
-  const lines = section.split(`
-`);
-  for (const line of lines) {
-    const match = line.match(/\|\s*`([^`]+)`\s*\|\s*(.+?)\s*\|/);
-    if (match && match[1] !== "Variable") {
-      vars.push({ variable: match[1], description: match[2].trim() });
-    }
-  }
-  return vars;
-}
-function removeConnector(name, targetDir = process.cwd()) {
-  const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  const connectorsDir = join2(targetDir, ".connectors");
-  const connectorPath = join2(connectorsDir, connectorName);
-  if (!existsSync2(connectorPath)) {
-    return false;
-  }
-  rmSync(connectorPath, { recursive: true });
-  updateConnectorsIndex(connectorsDir);
-  return true;
-}
+// src/mcp/index.ts
+init_installer();
 
 // src/server/auth.ts
 import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync3 } from "fs";
+init_installer();
 import { homedir as homedir3 } from "os";
 import { join as join4 } from "path";
 
@@ -26366,6 +26705,16 @@ function loadTokens(name) {
       return null;
     }
   }
+  const profileConfig = loadProfileConfig(name);
+  if (profileConfig.refreshToken || profileConfig.accessToken) {
+    return {
+      accessToken: profileConfig.accessToken,
+      refreshToken: profileConfig.refreshToken,
+      expiresAt: profileConfig.expiresAt,
+      tokenType: profileConfig.tokenType,
+      scope: profileConfig.scope
+    };
+  }
   return null;
 }
 function getAuthStatus(name) {
@@ -26733,7 +27082,7 @@ init_strip();
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.2.0",
+  version: "1.3.1",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {
@@ -26832,8 +27181,15 @@ server.registerTool("search_connectors", {
   description: "Search connectors by name or keyword.",
   inputSchema: { query: exports_external.string() }
 }, async ({ query }) => {
-  const results = searchConnectors(query);
-  return stripped(JSON.stringify(results.map((c) => ({ name: c.name, displayName: c.displayName, version: c.version, category: c.category, description: c.description })), null, 2));
+  const { getInstalledConnectors: getInstalledConnectors2 } = await Promise.resolve().then(() => (init_installer(), exports_installer));
+  const { getPromotedConnectors: getPromotedConnectors2 } = await Promise.resolve().then(() => (init_promotions(), exports_promotions));
+  const { getUsageMap: getUsageMap2 } = await Promise.resolve().then(() => (init_usage(), exports_usage));
+  const results = searchConnectors(query, {
+    installed: getInstalledConnectors2(),
+    promoted: getPromotedConnectors2(),
+    usage: getUsageMap2()
+  });
+  return stripped(JSON.stringify(results.map((c) => ({ name: c.name, displayName: c.displayName, version: c.version, category: c.category, description: c.description, score: c.score, badges: c.badges })), null, 2));
 });
 server.registerTool("list_connectors", {
   title: "List Connectors",
@@ -27127,6 +27483,10 @@ server.registerTool("run_connector_operation", {
       isError: true
     };
   }
+  try {
+    const { logUsage: logUsage2 } = await Promise.resolve().then(() => (init_usage(), exports_usage));
+    logUsage2(name, "run");
+  } catch {}
   const finalArgs = [...args];
   if (format) {
     finalArgs.push("--format", format);
@@ -27295,6 +27655,27 @@ server.registerTool("describe_tools", {
 `);
   return { content: [{ type: "text", text: result }] };
 });
+server.registerTool("get_hot_connectors", { title: "Get Hot Connectors", description: "Top connectors by usage.", inputSchema: { limit: exports_external.number().optional(), days: exports_external.number().optional() } }, async ({ limit, days }) => {
+  const { getTopConnectors: getTopConnectors2 } = await Promise.resolve().then(() => (init_usage(), exports_usage));
+  const { getPromotedConnectors: getPromotedConnectors2 } = await Promise.resolve().then(() => (init_promotions(), exports_promotions));
+  const top = getTopConnectors2(limit ?? 10, days ?? 7);
+  const promoted = new Set(getPromotedConnectors2());
+  const result = top.map((t) => ({ ...t, promoted: promoted.has(t.connector) }));
+  return stripped(JSON.stringify(result, null, 2));
+});
+server.registerTool("promote_connector", { title: "Promote Connector", description: "Boost a connector in search rankings.", inputSchema: { name: exports_external.string() } }, async ({ name }) => {
+  const meta = getConnector(name);
+  if (!meta)
+    return { content: [{ type: "text", text: JSON.stringify({ error: "Connector not found" }) }], isError: true };
+  const { promoteConnector: promoteConnector2 } = await Promise.resolve().then(() => (init_promotions(), exports_promotions));
+  promoteConnector2(name);
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, connector: name }) }] };
+});
+server.registerTool("demote_connector", { title: "Demote Connector", description: "Remove search ranking boost.", inputSchema: { name: exports_external.string() } }, async ({ name }) => {
+  const { demoteConnector: demoteConnector2 } = await Promise.resolve().then(() => (init_promotions(), exports_promotions));
+  const removed = demoteConnector2(name);
+  return { content: [{ type: "text", text: JSON.stringify({ success: removed, connector: name }) }] };
+});
 server.registerTool("list_jobs", { title: "List Jobs", description: "List scheduled connector jobs.", inputSchema: {} }, async () => {
   const { listJobs: listJobs2 } = await Promise.resolve().then(() => (init_jobs(), exports_jobs));
   const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_database(), exports_database));