@hasna/connectors 1.3.2 → 1.3.5

package/dist/index.js

@@ -5,6 +5,94 @@ var __require = import.meta.require;
 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",
@@ -410,6 +498,13 @@ var CONNECTORS = [
     category: "Data & Analytics",
     tags: ["weather", "data"]
   },
+  {
+    name: "arxiv",
+    displayName: "arXiv",
+    description: "Research paper search and retrieval",
+    category: "Data & Analytics",
+    tags: ["research", "papers", "academic"]
+  },
   {
     name: "brandsight",
     displayName: "Brandsight",
@@ -4890,13 +4985,6 @@ var CONNECTORS = [
     category: "Business Tools",
     tags: ["e-signature", "contracts", "digital", "documents", "legal"]
   },
-  {
-    name: "yousign",
-    displayName: "Yousign",
-    description: "eIDAS-compliant electronic signature API for EU workflows",
-    category: "Business Tools",
-    tags: ["e-signature", "eidas", "contracts", "documents", "legal", "eu"]
-  },
   {
     name: "signl4",
     displayName: "SIGNL4",
@@ -5930,9 +6018,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);
@@ -5961,7 +6192,8 @@ function loadConnectorVersions() {
   }
 }
 // src/lib/installer.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+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));
@@ -5983,6 +6215,7 @@ 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,
@@ -5990,7 +6223,10 @@ function installConnector(name, options = {}) {
       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,
@@ -5998,21 +6234,74 @@ function installConnector(name, options = {}) {
       error: `Connector '${name}' not found`
     };
   }
-  return {
-    connector: name,
-    success: true,
-    path: sourcePath
-  };
+  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 (error) {
+    return {
+      connector: name,
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
 }
 function installConnectors(names, options = {}) {
   return names.map((name) => installConnector(name, options));
 }
-function getInstalledConnectors() {
-  if (!existsSync2(CONNECTORS_DIR)) {
+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(CONNECTORS_DIR).filter((f) => {
-    const fullPath = join2(CONNECTORS_DIR, f);
+  return readdirSync(connectorsDir).filter((f) => {
+    const fullPath = join2(connectorsDir, f);
     return f.startsWith("connect-") && statSync(fullPath).isDirectory();
   }).map((f) => f.replace("connect-", ""));
 }
@@ -6058,8 +6347,16 @@ function parseEnvVarsTable(section) {
   }
   return vars;
 }
-function removeConnector(name) {
-  return false;
+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/lib/runner.ts
 import { existsSync as existsSync3 } from "fs";

package/dist/lib/fuzzy.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Levenshtein distance for fuzzy connector search.
+ * No dependencies — pure implementation.
+ */
+/** Compute edit distance between two strings */
+export declare function levenshtein(a: string, b: string): number;
+/**
+ * Check if token fuzzy-matches target within maxDistance.
+ * Only applies to tokens >= 3 chars to avoid false positives.
+ */
+export declare function fuzzyMatch(token: string, target: string, maxDistance?: number): boolean;
+/**
+ * Find best fuzzy match score for a token against a list of candidates.
+ * Returns 0 if no match within threshold.
+ */
+export declare function bestFuzzyScore(token: string, candidates: string[], maxDistance?: number): number;

package/dist/lib/fuzzy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/installer.d.ts

@@ -8,6 +8,7 @@ export interface InstallResult {
     path?: string;
 }
 export interface InstallOptions {
+    targetDir?: string;
     overwrite?: boolean;
 }
 /**
@@ -19,8 +20,7 @@ export declare function getConnectorPath(name: string): string;
  */
 export declare function connectorExists(name: string): boolean;
 /**
- * Install a single connector — verifies it exists in the global package.
- * Auth/tokens always live in ~/.connectors/connect-{name}/ and are never touched here.
+ * Install a single connector to the target directory
  */
 export declare function installConnector(name: string, options?: InstallOptions): InstallResult;
 /**
@@ -28,9 +28,9 @@ export declare function installConnector(name: string, options?: InstallOptions)
  */
 export declare function installConnectors(names: string[], options?: InstallOptions): InstallResult[];
 /**
- * Get list of available connectors from the global package
+ * Get list of installed connectors in a directory
  */
-export declare function getInstalledConnectors(): string[];
+export declare function getInstalledConnectors(targetDir?: string): string[];
 /**
  * Parsed documentation from a connector's CLAUDE.md
  */
@@ -50,7 +50,6 @@ export interface ConnectorDocs {
  */
 export declare function getConnectorDocs(name: string): ConnectorDocs | null;
 /**
- * Remove a connector — connectors are part of the global package and cannot be
- * individually removed. This always returns false.
+ * Remove an installed connector
  */
-export declare function removeConnector(name: string): boolean;
+export declare function removeConnector(name: string, targetDir?: string): boolean;

package/dist/lib/llm.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Provider-agnostic LLM client for open-connectors.
+ *
+ * Supports: cerebras, groq, openai, anthropic
+ * Config stored at: ~/.connectors/llm.json
+ *
+ * Cerebras and Groq are OpenAI-compatible (same SDK, different base URLs).
+ * Anthropic has its own API format.
+ */
+export type LLMProvider = "cerebras" | "groq" | "openai" | "anthropic";
+export interface LLMConfig {
+    provider: LLMProvider;
+    model: string;
+    api_key: string;
+    strip: boolean;
+}
+export interface LLMResponse {
+    content: string;
+    provider: LLMProvider;
+    model: string;
+    latency_ms: number;
+}
+export declare const PROVIDER_DEFAULTS: Record<LLMProvider, {
+    model: string;
+}>;
+export declare function getLlmConfig(): LLMConfig | null;
+export declare function saveLlmConfig(config: LLMConfig): void;
+export declare function setLlmStrip(enabled: boolean): void;
+export declare function isStripEnabled(): boolean;
+/** Mask API key for display: show first 8 chars + *** */
+export declare function maskKey(key: string): string;
+export declare class LLMClient {
+    private config;
+    constructor(config: LLMConfig);
+    static fromConfig(): LLMClient | null;
+    complete(prompt: string, content: string): Promise<LLMResponse>;
+    private _anthropicComplete;
+}

package/dist/lib/llm.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/lock.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Advisory file-based write lock for per-connector operations.
+ *
+ * Prevents concurrent agents from racing on token refresh and config writes.
+ * Reads remain unaffected — only write operations (saveApiKey, refreshOAuthToken,
+ * switchProfile) acquire the lock.
+ *
+ * Strategy: atomic O_EXCL file creation as the lock primitive (works on all
+ * platforms including macOS). Lock files live at:
+ *   ~/.connectors/connect-{name}/.write.lock
+ *
+ * Callers that cannot acquire the lock within the timeout receive a LockTimeoutError.
+ */
+export declare class LockTimeoutError extends Error {
+    readonly connector: string;
+    constructor(connector: string);
+}
+/**
+ * Acquire a write lock for a connector, run the callback, then release.
+ * Throws LockTimeoutError if the lock cannot be acquired within LOCK_TIMEOUT_MS.
+ */
+export declare function withWriteLock<T>(connector: string, fn: () => T | Promise<T>): Promise<T>;

package/dist/lib/lock.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/registry.d.ts

@@ -13,6 +13,27 @@ export declare const CATEGORIES: readonly ["AI & ML", "Developer Tools", "Design
 export type Category = (typeof CATEGORIES)[number];
 export declare const CONNECTORS: ConnectorMeta[];
 export declare function getConnectorsByCategory(category: Category): ConnectorMeta[];
-export declare function searchConnectors(query: string): ConnectorMeta[];
+export interface SearchContext {
+    installed?: string[];
+    promoted?: string[];
+    usage?: Map<string, number>;
+}
+export interface ScoredResult extends ConnectorMeta {
+    score: number;
+    matchReasons: string[];
+    badges: string[];
+}
+/**
+ * Ranked connector search with multi-token AND, scoring, and context signals.
+ *
+ * Score formula:
+ *   relevance (name/tag/displayName/description matches)
+ *   + installed boost (+50)
+ *   + promoted boost (+30)
+ *   + usage boost (min(count * 2, 40))
+ */
+export declare function searchConnectors(query: string, context?: SearchContext & {
+    limit?: number;
+}): ScoredResult[];
 export declare function getConnector(name: string): ConnectorMeta | undefined;
 export declare function loadConnectorVersions(): void;

package/dist/lib/scheduler.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Connector job scheduler.
+ *
+ * Checks enabled jobs against their cron expressions and runs them
+ * when due. Runs in-process as part of `connectors serve`.
+ *
+ * Cron format: minute hour day month weekday (5-field standard)
+ * Uses a lightweight cron matcher — no external dep needed.
+ */
+import type { Database } from "bun:sqlite";
+import { type ConnectorJob } from "../db/jobs.js";
+/** Start the scheduler. Checks every 30s, fires jobs when cron matches. */
+export declare function startScheduler(db: Database): void;
+export declare function stopScheduler(): void;
+/** Manually trigger a job by ID (for CLI 'connectors jobs run') */
+export declare function triggerJob(job: ConnectorJob, db: Database): Promise<{
+    run_id: string;
+    exit_code: number;
+    output: string;
+}>;

package/dist/lib/scheduler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/strip.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Global output stripping middleware.
+ *
+ * When strip is enabled in ~/.connectors/llm.json, every output surface
+ * (MCP, REST, CLI) passes through maybeStrip() before returning to the caller.
+ * This reduces token consumption for AI agents consuming connector output.
+ *
+ * If strip is disabled or no LLM config exists, output is returned as-is.
+ */
+export type StripType = "json" | "text";
+/**
+ * Conditionally strip output through LLM if strip is enabled.
+ * Returns output unchanged if strip is disabled or LLM not configured.
+ */
+export declare function maybeStrip(output: string, _type?: StripType): Promise<string>;
+/**
+ * Synchronous passthrough check — returns true if stripping is active.
+ * Use this to decide whether to await maybeStrip or skip it.
+ */
+export declare function isStrippingActive(): boolean;

package/dist/lib/strip.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/synonyms.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Synonym expansion for connector search.
+ * Domain-specific terms only — not a general thesaurus.
+ */
+/**
+ * Expand search tokens with domain synonyms.
+ * Returns original tokens + synonym tokens (deduplicated).
+ */
+export declare function expandQuery(tokens: string[]): {
+    original: string[];
+    expanded: string[];
+};

package/dist/lib/synonyms.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/workflow-runner.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Workflow runner — executes sequential connector pipelines.
+ *
+ * Each step receives the previous step's output as additional context
+ * injected into its args as --input <previous_output>.
+ */
+import type { ConnectorWorkflow } from "../db/workflows.js";
+export interface WorkflowStepResult {
+    step: number;
+    connector: string;
+    command: string;
+    exit_code: number;
+    output: string;
+}
+export interface WorkflowResult {
+    workflow_id: string;
+    workflow_name: string;
+    steps: WorkflowStepResult[];
+    success: boolean;
+    final_output: string;
+}
+export declare function runWorkflow(workflow: ConnectorWorkflow): Promise<WorkflowResult>;

package/dist/server/auth.d.ts

@@ -42,7 +42,7 @@ export declare function getEnvVars(name: string): {
 /**
  * Save an API key to a connector's profile
  */
-export declare function saveApiKey(name: string, key: string, field?: string): void;
+export declare function saveApiKey(name: string, key: string, field?: string): Promise<void>;
 /**
  * Get OAuth client credentials for a connector
  */
@@ -63,7 +63,9 @@ export declare function validateOAuthState(state: string | null, expectedConnect
  */
 export declare function exchangeOAuthCode(name: string, code: string, redirectUri: string): Promise<OAuthTokens>;
 /**
- * Refresh an OAuth token using the stored refresh token
+ * Refresh an OAuth token using the stored refresh token.
+ * Serialized with a per-connector write lock to prevent concurrent agents
+ * from racing on token refresh (double-refresh race condition).
  */
 export declare function refreshOAuthToken(name: string): Promise<OAuthTokens>;
 /**