@hasna/connectors 1.2.0 → 1.3.0

package/bin/index.js

@@ -4,6 +4,7 @@ var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __toESM = (mod, isNodeMode, target) => {
   target = mod != null ? __create(__getProtoOf(mod)) : {};
@@ -16,6 +17,20 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
@@ -2099,6 +2114,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(() => {
@@ -2424,6 +2455,95 @@ var init_workflow_runner = __esm(() => {
   init_strip();
 });
 
+// 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
+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] };
+}
+var SYNONYM_MAP;
+var init_synonyms = __esm(() => {
+  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"]
+  };
+});
+
 // src/lib/registry.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { join as join3, dirname } from "path";
@@ -2431,9 +2551,152 @@ import { fileURLToPath } from "url";
 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);
@@ -2462,6 +2725,7 @@ function loadConnectorVersions() {
 }
 var CATEGORIES, CONNECTORS, versionsLoaded = false;
 var init_registry = __esm(() => {
+  init_synonyms();
   CATEGORIES = [
     "AI & ML",
     "Developer Tools",
@@ -10318,6 +10582,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) {
@@ -10643,6 +10917,75 @@ var init_auth = __esm(() => {
   };
 });
 
+// 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/agents.ts
 function shortUuid2() {
   return crypto.randomUUID().slice(0, 8);
@@ -11071,6 +11414,30 @@ Dashboard not found at: ${dashboardDir}`);
       if (path === "/api/activity" && method === "GET") {
         return json(activityLog, 200, port);
       }
+      if (path === "/api/hot" && method === "GET") {
+        const { getTopConnectors: getTopConnectors2 } = await Promise.resolve().then(() => (init_usage(), exports_usage));
+        const { getPromotedConnectors: getPromotedConnectors2 } = await Promise.resolve().then(() => (init_promotions(), exports_promotions));
+        const limit = parseInt(url2.searchParams.get("limit") || "10", 10);
+        const days = parseInt(url2.searchParams.get("days") || "7", 10);
+        const db = getDatabase2();
+        const top = getTopConnectors2(limit, days, db);
+        const promoted = new Set(getPromotedConnectors2(db));
+        return json(top.map((t) => ({ ...t, promoted: promoted.has(t.connector) })), 200, port);
+      }
+      const promoteMatch = path.match(/^\/api\/connectors\/([^/]+)\/promote$/);
+      if (promoteMatch && method === "POST") {
+        const name = promoteMatch[1];
+        if (!getConnector(name))
+          return json({ error: "Connector not found" }, 404, port);
+        const { promoteConnector: promoteConnector2 } = await Promise.resolve().then(() => (init_promotions(), exports_promotions));
+        promoteConnector2(name, getDatabase2());
+        return json({ success: true, connector: name }, 200, port);
+      }
+      if (promoteMatch && method === "DELETE") {
+        const { demoteConnector: demoteConnector2 } = await Promise.resolve().then(() => (init_promotions(), exports_promotions));
+        const removed = demoteConnector2(promoteMatch[1], getDatabase2());
+        return json({ success: removed, connector: promoteMatch[1] }, 200, port);
+      }
       if (path === "/api/llm" && method === "GET") {
         const config = getLlmConfig();
         if (!config)
@@ -11484,7 +11851,7 @@ import chalk2 from "chalk";
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.1.18",
+  version: "1.2.1",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {
@@ -13738,10 +14105,18 @@ Available connectors (${CONNECTORS.length}):
     console.log();
   }
 });
-program2.command("search").argument("<query>", "Search term").option("--json", "Output as JSON", false).description("Search for connectors").action((query, options) => {
-  const results = searchConnectors(query);
+program2.command("search").argument("<query>", "Search term").option("--json", "Output as JSON", false).option("--limit <n>", "Max results", "20").description("Search for connectors (ranked with fuzzy matching)").action((query, options) => {
+  const installed = getInstalledConnectors();
+  const { getPromotedConnectors: getPromotedConnectors2 } = (init_promotions(), __toCommonJS(exports_promotions));
+  const { getUsageMap: getUsageMap2 } = (init_usage(), __toCommonJS(exports_usage));
+  const results = searchConnectors(query, {
+    installed,
+    promoted: getPromotedConnectors2(),
+    usage: getUsageMap2(),
+    limit: parseInt(options.limit)
+  });
   if (options.json) {
-    console.log(JSON.stringify(results));
+    console.log(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, matchReasons: c.matchReasons }))));
     return;
   }
   if (results.length === 0) {
@@ -13751,10 +14126,12 @@ program2.command("search").argument("<query>", "Search term").option("--json", "
   console.log(chalk2.bold(`
 Found ${results.length} connector(s):
 `));
-  console.log(`  ${chalk2.dim("Name".padEnd(20))}${chalk2.dim("Version".padEnd(10))}${chalk2.dim("Category".padEnd(20))}${chalk2.dim("Description")}`);
-  console.log(chalk2.dim(`  ${"\u2500".repeat(70)}`));
+  console.log(`  ${chalk2.dim("Name".padEnd(22))}${chalk2.dim("Score".padEnd(7))}${chalk2.dim("Category".padEnd(20))}${chalk2.dim("Description")}`);
+  console.log(chalk2.dim(`  ${"\u2500".repeat(75)}`));
   for (const c of results) {
-    console.log(`  ${chalk2.cyan(c.name.padEnd(20))}${chalk2.dim((c.version || "-").padEnd(10))}${chalk2.dim(c.category.padEnd(20))}${c.description}`);
+    const badges = c.badges.map((b) => b === "installed" ? chalk2.green("[INS]") : b === "hot" ? chalk2.red("[HOT]") : b === "promoted" ? chalk2.yellow("[PRO]") : "").join(" ");
+    const badgeStr = badges ? " " + badges : "";
+    console.log(`  ${chalk2.cyan(c.name.padEnd(22))}${String(c.score).padEnd(7)}${chalk2.dim(c.category.padEnd(20))}${c.description}${badgeStr}`);
   }
 });
 program2.command("info").argument("<connector>", "Connector name").option("--json", "Output as JSON", false).description("Show detailed info about a connector").action((connector, options) => {
@@ -15464,6 +15841,51 @@ Setting up ${meta.displayName}...
   }
   process.exit(0);
 });
+program2.command("hot").description("Show top connectors by usage").option("--limit <n>", "Max results", "10").option("--days <n>", "Time window in days", "7").option("--json", "Output as JSON").action((options) => {
+  const { getTopConnectors: getTopConnectors2 } = (init_usage(), __toCommonJS(exports_usage));
+  const { getPromotedConnectors: getPromotedConnectors2 } = (init_promotions(), __toCommonJS(exports_promotions));
+  const top = getTopConnectors2(parseInt(options.limit), parseInt(options.days), getDatabase());
+  const promoted = new Set(getPromotedConnectors2(getDatabase()));
+  if (options.json) {
+    console.log(JSON.stringify(top.map((t) => ({ ...t, promoted: promoted.has(t.connector) }))));
+    return;
+  }
+  if (top.length === 0) {
+    console.log(chalk2.dim("No usage data yet. Use connectors to build up stats."));
+    return;
+  }
+  console.log(chalk2.bold(`
+Top connectors (last ${options.days} days):
+`));
+  console.log(`  ${chalk2.dim("#".padEnd(4))}${chalk2.dim("Connector".padEnd(22))}${chalk2.dim("Usage".padEnd(8))}${chalk2.dim("Badges")}`);
+  console.log(chalk2.dim(`  ${"\u2500".repeat(45)}`));
+  for (let i = 0;i < top.length; i++) {
+    const t = top[i];
+    const badges = [
+      t.count >= 5 ? chalk2.red("[HOT]") : "",
+      promoted.has(t.connector) ? chalk2.yellow("[PRO]") : ""
+    ].filter(Boolean).join(" ");
+    console.log(`  ${String(i + 1).padEnd(4)}${chalk2.cyan(t.connector.padEnd(22))}${String(t.count).padEnd(8)}${badges}`);
+  }
+});
+program2.command("promote").argument("<connector>", "Connector to promote").description("Mark a connector as promoted (boosted in search)").action((connector) => {
+  const meta = getConnector(connector);
+  if (!meta) {
+    console.error(chalk2.red(`Connector '${connector}' not found`));
+    process.exit(1);
+  }
+  const { promoteConnector: promoteConnector2 } = (init_promotions(), __toCommonJS(exports_promotions));
+  promoteConnector2(connector, getDatabase());
+  console.log(chalk2.green("\u2713") + ` ${meta.displayName} promoted \u2014 will rank higher in search`);
+});
+program2.command("demote").argument("<connector>", "Connector to demote").description("Remove promotion from a connector").action((connector) => {
+  const { demoteConnector: demoteConnector2 } = (init_promotions(), __toCommonJS(exports_promotions));
+  const removed = demoteConnector2(connector, getDatabase());
+  if (removed)
+    console.log(chalk2.green("\u2713") + ` ${connector} demoted`);
+  else
+    console.log(chalk2.dim(`${connector} was not promoted`));
+});
 var jobsCmd = program2.command("jobs").description("Manage scheduled connector jobs");
 jobsCmd.command("add").description("Add a scheduled job").requiredOption("--name <name>", "Job name").requiredOption("--connector <connector>", "Connector name").requiredOption("--command <command>", "Command to run").requiredOption("--cron <cron>", "Cron expression (5-field)").option("--args <args>", "Command args (space-separated)").option("--strip", "Apply LLM stripping to output").option("--json", "Output as JSON").action((options) => {
   const db = getDatabase();