@hasna/connectors 1.3.2 → 1.3.3

package/dist/db/locks.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Resource lock helpers for open-connectors.
+ *
+ * Same interface as open-mementos src/db/locks.ts — standard pattern across
+ * all @hasna apps. Resource types are scoped to what connectors manages:
+ *   connector — the connector itself (install/uninstall ops)
+ *   agent     — agent records
+ *   profile   — connector auth profiles
+ *   token     — OAuth token refresh operations
+ */
+import type { Database } from "bun:sqlite";
+export type ResourceType = "connector" | "agent" | "profile" | "token";
+export type LockType = "advisory" | "exclusive";
+export interface ResourceLock {
+    id: string;
+    resource_type: ResourceType;
+    resource_id: string;
+    agent_id: string;
+    lock_type: LockType;
+    locked_at: string;
+    expires_at: string;
+}
+/**
+ * Acquire a lock on a resource.
+ * - advisory: multiple agents can hold advisory locks simultaneously
+ * - exclusive: only one agent can hold an exclusive lock at a time
+ *
+ * Returns the lock if acquired, null if blocked by an existing exclusive lock.
+ * TTL is in seconds (default: 5 minutes).
+ */
+export declare function acquireLock(agentId: string, resourceType: ResourceType, resourceId: string, lockType?: LockType, ttlSeconds?: number, db?: Database): ResourceLock | null;
+/**
+ * Release a specific lock by ID. Only the owning agent can release it.
+ */
+export declare function releaseLock(lockId: string, agentId: string, db?: Database): boolean;
+/**
+ * Release all locks held by an agent on a specific resource.
+ */
+export declare function releaseResourceLocks(agentId: string, resourceType: ResourceType, resourceId: string, db?: Database): number;
+/**
+ * Release all locks held by an agent (e.g., on session end).
+ */
+export declare function releaseAllAgentLocks(agentId: string, db?: Database): number;
+/**
+ * Check if a resource is currently locked. Returns active lock(s) or empty array.
+ */
+export declare function checkLock(resourceType: ResourceType, resourceId: string, lockType?: LockType, db?: Database): ResourceLock[];
+/**
+ * Check if a specific agent holds a lock on a resource.
+ */
+export declare function agentHoldsLock(agentId: string, resourceType: ResourceType, resourceId: string, lockType?: LockType, db?: Database): ResourceLock | null;
+/**
+ * List all active locks for an agent.
+ */
+export declare function listAgentLocks(agentId: string, db?: Database): ResourceLock[];
+/**
+ * Delete all expired locks. Called automatically by other lock functions.
+ */
+export declare function cleanExpiredLocks(db?: Database): number;

package/dist/db/locks.test.d.ts

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

package/dist/db/promotions.d.ts

@@ -0,0 +1,5 @@
+import type { Database } from "bun:sqlite";
+export declare function promoteConnector(name: string, db?: Database): void;
+export declare function demoteConnector(name: string, db?: Database): boolean;
+export declare function getPromotedConnectors(db?: Database): string[];
+export declare function isPromoted(name: string, db?: Database): boolean;

package/dist/db/promotions.test.d.ts

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

package/dist/db/rate.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Agent-aware rate budget splitting for connector operations.
+ *
+ * When multiple agents share a connector, the connector's rate limit is split
+ * evenly among active agents (last heartbeat < 30min). Each agent gets:
+ *   budget = Math.floor(connectorRateLimit / activeAgentCount)
+ *
+ * Rate usage is tracked per-agent-per-connector in the DB:
+ *   connector_rate_usage(agent_id, connector, window_start, call_count)
+ *
+ * The window resets every WINDOW_SECONDS (default: 60s = per-minute rate).
+ */
+import type { Database } from "bun:sqlite";
+export interface RateBudget {
+    connector: string;
+    agent_id: string;
+    limit: number;
+    active_agents: number;
+    budget: number;
+    used: number;
+    remaining: number;
+    window_start: string;
+    window_resets_in_ms: number;
+}
+export interface RateExceededError {
+    exceeded: true;
+    connector: string;
+    agent_id: string;
+    budget: number;
+    used: number;
+    active_agents: number;
+    window_resets_in_ms: number;
+    message: string;
+}
+export declare function isRateExceeded(result: RateBudget | RateExceededError): result is RateExceededError;
+/**
+ * Ensure the rate_usage table exists (idempotent).
+ */
+export declare function ensureRateTable(db: Database): void;
+/**
+ * Check and optionally consume one rate budget unit for an agent+connector.
+ *
+ * @param agentId - Agent ID (from agents table)
+ * @param connector - Connector name (e.g. "stripe")
+ * @param connectorLimit - The connector's documented rate limit (calls/min)
+ * @param consume - If true, increment the call counter. If false, just peek.
+ * @param db - Optional DB instance (defaults to singleton)
+ */
+export declare function checkRateBudget(agentId: string, connector: string, connectorLimit: number, consume?: boolean, db?: Database): RateBudget | RateExceededError;
+/**
+ * Get rate budget status without consuming a unit.
+ */
+export declare function getRateBudget(agentId: string, connector: string, connectorLimit: number, db?: Database): RateBudget | RateExceededError;
+/**
+ * Clean up old rate windows (older than 2 windows).
+ */
+export declare function cleanExpiredRateWindows(db?: Database): number;

package/dist/db/rate.test.d.ts

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

package/dist/db/usage.d.ts

@@ -0,0 +1,17 @@
+import type { Database } from "bun:sqlite";
+export declare function logUsage(connector: string, action: string, agentId?: string, db?: Database): void;
+export interface UsageStats {
+    connector: string;
+    total: number;
+    last7d: number;
+    last24h: number;
+}
+export declare function getUsageStats(connector: string, db?: Database): UsageStats;
+export interface TopConnector {
+    connector: string;
+    count: number;
+}
+export declare function getTopConnectors(limit?: number, days?: number, db?: Database): TopConnector[];
+/** Get usage counts as a Map for search context */
+export declare function getUsageMap(days?: number, db?: Database): Map<string, number>;
+export declare function cleanOldUsage(days?: number, db?: Database): number;

package/dist/db/usage.test.d.ts

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

package/dist/db/workflows.d.ts

@@ -0,0 +1,26 @@
+import type { Database } from "bun:sqlite";
+export interface WorkflowStep {
+    connector: string;
+    command: string;
+    args?: string[];
+}
+export interface ConnectorWorkflow {
+    id: string;
+    name: string;
+    steps: WorkflowStep[];
+    enabled: boolean;
+    created_at: string;
+}
+export declare function createWorkflow(input: {
+    name: string;
+    steps: WorkflowStep[];
+}, db?: Database): ConnectorWorkflow;
+export declare function getWorkflow(id: string, db?: Database): ConnectorWorkflow | null;
+export declare function getWorkflowByName(name: string, db?: Database): ConnectorWorkflow | null;
+export declare function listWorkflows(db?: Database): ConnectorWorkflow[];
+export declare function updateWorkflow(id: string, input: Partial<{
+    name: string;
+    steps: WorkflowStep[];
+    enabled: boolean;
+}>, db?: Database): ConnectorWorkflow;
+export declare function deleteWorkflow(id: string, db?: Database): boolean;

package/dist/db/workflows.test.d.ts

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

package/dist/index.d.ts

@@ -7,6 +7,6 @@
  * Or use the interactive CLI:
  *   npx @hasna/connectors
  */
-export { CONNECTORS, CATEGORIES, getConnector, getConnectorsByCategory, searchConnectors, loadConnectorVersions, type ConnectorMeta, type Category, } from "./lib/registry.js";
+export { CONNECTORS, CATEGORIES, getConnector, getConnectorsByCategory, searchConnectors, loadConnectorVersions, type ConnectorMeta, type Category, type ScoredResult, type SearchContext, } from "./lib/registry.js";
 export { installConnector, installConnectors, getInstalledConnectors, removeConnector, connectorExists, getConnectorPath, getConnectorDocs, type InstallResult, type InstallOptions, type ConnectorDocs, } from "./lib/installer.js";
 export { runConnectorCommand, getConnectorOperations, getConnectorCommandHelp, getConnectorCliPath, getConnectorsWithCli, type RunResult, } from "./lib/runner.js";

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",
@@ -4890,13 +4978,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 +6011,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 +6185,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 +6208,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 +6216,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 +6227,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 +6340,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;