@hasna/connectors 1.3.2 → 1.3.5

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)
@@ -1868,16 +1883,820 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// src/lib/llm.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getLlmConfigPath() {
+  return join(homedir(), ".connectors", "llm.json");
+}
+function getLlmConfig() {
+  const path = getLlmConfigPath();
+  if (!existsSync(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveLlmConfig(config) {
+  const dir = join(homedir(), ".connectors");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(getLlmConfigPath(), JSON.stringify(config, null, 2));
+}
+function setLlmStrip(enabled) {
+  const config = getLlmConfig();
+  if (!config)
+    throw new Error("No LLM config found. Run: connectors llm set --provider <provider> --key <key>");
+  saveLlmConfig({ ...config, strip: enabled });
+}
+function maskKey(key) {
+  if (key.length <= 8)
+    return "***";
+  return key.slice(0, 8) + "***";
+}
+
+class LLMClient {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  static fromConfig() {
+    const config = getLlmConfig();
+    if (!config)
+      return null;
+    return new LLMClient(config);
+  }
+  async complete(prompt, content) {
+    const start = Date.now();
+    const { provider, model, api_key } = this.config;
+    if (provider === "anthropic") {
+      return this._anthropicComplete(prompt, content, start);
+    }
+    const baseUrl = PROVIDER_BASE_URLS[provider];
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${api_key}`
+      },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: "system", content: prompt },
+          { role: "user", content }
+        ],
+        temperature: 0,
+        max_tokens: 4096
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`LLM request failed (${provider} ${response.status}): ${error}`);
+    }
+    const data = await response.json();
+    return {
+      content: data.choices[0].message.content,
+      provider,
+      model,
+      latency_ms: Date.now() - start
+    };
+  }
+  async _anthropicComplete(prompt, content, start) {
+    const { model, api_key } = this.config;
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": api_key,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model,
+        system: prompt,
+        messages: [{ role: "user", content }],
+        max_tokens: 4096
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`LLM request failed (anthropic ${response.status}): ${error}`);
+    }
+    const data = await response.json();
+    return {
+      content: data.content[0].text,
+      provider: "anthropic",
+      model,
+      latency_ms: Date.now() - start
+    };
+  }
+}
+var PROVIDER_BASE_URLS, PROVIDER_DEFAULTS;
+var init_llm = __esm(() => {
+  PROVIDER_BASE_URLS = {
+    cerebras: "https://api.cerebras.ai/v1",
+    groq: "https://api.groq.com/openai/v1",
+    openai: "https://api.openai.com/v1"
+  };
+  PROVIDER_DEFAULTS = {
+    cerebras: { model: "qwen-3-32b" },
+    groq: { model: "llama-3.3-70b-versatile" },
+    openai: { model: "gpt-4o-mini" },
+    anthropic: { model: "claude-haiku-4-5-20251001" }
+  };
+});
+
+// src/db/database.ts
+var exports_database = {};
+__export(exports_database, {
+  shortUuid: () => shortUuid,
+  now: () => now,
+  getDatabase: () => getDatabase,
+  closeDatabase: () => closeDatabase
+});
+import { Database } from "bun:sqlite";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { mkdirSync as mkdirSync2 } from "fs";
+function getDatabase(path) {
+  if (_db)
+    return _db;
+  const dbPath = path ?? DB_PATH;
+  mkdirSync2(join2(dbPath, ".."), { recursive: true });
+  _db = new Database(dbPath);
+  _db.run("PRAGMA journal_mode = WAL");
+  migrate(_db);
+  return _db;
+}
+function closeDatabase() {
+  _db?.close();
+  _db = null;
+}
+function now() {
+  return new Date().toISOString();
+}
+function shortUuid() {
+  return crypto.randomUUID().slice(0, 8);
+}
+function migrate(db) {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS agents (
+      id TEXT PRIMARY KEY,
+      name TEXT UNIQUE NOT NULL,
+      session_id TEXT,
+      role TEXT NOT NULL DEFAULT 'agent',
+      last_seen_at TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS resource_locks (
+      id TEXT PRIMARY KEY,
+      resource_type TEXT NOT NULL CHECK(resource_type IN ('connector', 'agent', 'profile', 'token')),
+      resource_id TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      lock_type TEXT NOT NULL DEFAULT 'exclusive' CHECK(lock_type IN ('advisory', 'exclusive')),
+      locked_at TEXT NOT NULL DEFAULT (datetime('now')),
+      expires_at TEXT NOT NULL
+    )
+  `);
+  db.run(`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_resource_locks_exclusive
+      ON resource_locks(resource_type, resource_id)
+      WHERE lock_type = 'exclusive'
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_resource_locks_agent ON resource_locks(agent_id)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_resource_locks_expires ON resource_locks(expires_at)`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_rate_usage (
+      agent_id TEXT NOT NULL,
+      connector TEXT NOT NULL,
+      window_start TEXT NOT NULL,
+      call_count INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (agent_id, connector, window_start)
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_rate_usage_window ON connector_rate_usage(connector, window_start)`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_jobs (
+      id TEXT PRIMARY KEY,
+      name TEXT UNIQUE NOT NULL,
+      connector TEXT NOT NULL,
+      command TEXT NOT NULL,
+      args TEXT NOT NULL DEFAULT '[]',
+      cron TEXT NOT NULL,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      strip INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      last_run_at TEXT
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_jobs_enabled ON connector_jobs(enabled)`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_job_runs (
+      id TEXT PRIMARY KEY,
+      job_id TEXT NOT NULL REFERENCES connector_jobs(id) ON DELETE CASCADE,
+      started_at TEXT NOT NULL,
+      finished_at TEXT,
+      exit_code INTEGER,
+      raw_output TEXT,
+      stripped_output TEXT
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_job_runs_job ON connector_job_runs(job_id, started_at DESC)`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_workflows (
+      id TEXT PRIMARY KEY,
+      name TEXT UNIQUE NOT NULL,
+      steps TEXT NOT NULL DEFAULT '[]',
+      enabled INTEGER NOT NULL DEFAULT 1,
+      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(() => {
+  DB_DIR = join2(homedir2(), ".connectors");
+  DB_PATH = join2(DB_DIR, "connectors.db");
+});
+
+// src/db/jobs.ts
+function rowToJob(row) {
+  return {
+    ...row,
+    args: JSON.parse(row.args || "[]"),
+    enabled: row.enabled === 1,
+    strip: row.strip === 1
+  };
+}
+function createJob(input, db) {
+  const d = db ?? getDatabase();
+  const id = shortUuid();
+  const ts = now();
+  d.run("INSERT INTO connector_jobs (id, name, connector, command, args, cron, enabled, strip, created_at) VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)", [id, input.name, input.connector, input.command, JSON.stringify(input.args ?? []), input.cron, input.strip ? 1 : 0, ts]);
+  return getJob(id, d);
+}
+function getJob(id, db) {
+  const d = db ?? getDatabase();
+  const row = d.query("SELECT * FROM connector_jobs WHERE id = ?").get(id);
+  return row ? rowToJob(row) : null;
+}
+function getJobByName(name, db) {
+  const d = db ?? getDatabase();
+  const row = d.query("SELECT * FROM connector_jobs WHERE name = ?").get(name);
+  return row ? rowToJob(row) : null;
+}
+function listJobs(db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM connector_jobs ORDER BY name").all().map(rowToJob);
+}
+function listEnabledJobs(db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM connector_jobs WHERE enabled = 1").all().map(rowToJob);
+}
+function updateJob(id, input, db) {
+  const d = db ?? getDatabase();
+  const sets = [];
+  const params = [];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.connector !== undefined) {
+    sets.push("connector = ?");
+    params.push(input.connector);
+  }
+  if (input.command !== undefined) {
+    sets.push("command = ?");
+    params.push(input.command);
+  }
+  if (input.args !== undefined) {
+    sets.push("args = ?");
+    params.push(JSON.stringify(input.args));
+  }
+  if (input.cron !== undefined) {
+    sets.push("cron = ?");
+    params.push(input.cron);
+  }
+  if (input.enabled !== undefined) {
+    sets.push("enabled = ?");
+    params.push(input.enabled ? 1 : 0);
+  }
+  if (input.strip !== undefined) {
+    sets.push("strip = ?");
+    params.push(input.strip ? 1 : 0);
+  }
+  if (sets.length === 0)
+    return getJob(id, d);
+  params.push(id);
+  d.run(`UPDATE connector_jobs SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getJob(id, d);
+}
+function deleteJob(id, db) {
+  const d = db ?? getDatabase();
+  return d.run("DELETE FROM connector_jobs WHERE id = ?", [id]).changes > 0;
+}
+function touchJobLastRun(id, db) {
+  const d = db ?? getDatabase();
+  d.run("UPDATE connector_jobs SET last_run_at = ? WHERE id = ?", [now(), id]);
+}
+function createJobRun(jobId, db) {
+  const d = db ?? getDatabase();
+  const id = shortUuid();
+  const ts = now();
+  d.run("INSERT INTO connector_job_runs (id, job_id, started_at) VALUES (?, ?, ?)", [id, jobId, ts]);
+  return { id, job_id: jobId, started_at: ts, finished_at: null, exit_code: null, raw_output: null, stripped_output: null };
+}
+function finishJobRun(id, result, db) {
+  const d = db ?? getDatabase();
+  d.run("UPDATE connector_job_runs SET finished_at = ?, exit_code = ?, raw_output = ?, stripped_output = ? WHERE id = ?", [now(), result.exit_code, result.raw_output, result.stripped_output ?? null, id]);
+}
+function listJobRuns(jobId, limit = 20, db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM connector_job_runs WHERE job_id = ? ORDER BY started_at DESC LIMIT ?").all(jobId, limit);
+}
+var init_jobs = __esm(() => {
+  init_database();
+});
+
+// src/db/workflows.ts
+function rowToWorkflow(row) {
+  return {
+    ...row,
+    steps: JSON.parse(row.steps || "[]"),
+    enabled: row.enabled === 1
+  };
+}
+function createWorkflow(input, db) {
+  const d = db ?? getDatabase();
+  const id = shortUuid();
+  d.run("INSERT INTO connector_workflows (id, name, steps, enabled, created_at) VALUES (?, ?, ?, 1, ?)", [id, input.name, JSON.stringify(input.steps), now()]);
+  return getWorkflow(id, d);
+}
+function getWorkflow(id, db) {
+  const d = db ?? getDatabase();
+  const row = d.query("SELECT * FROM connector_workflows WHERE id = ?").get(id);
+  return row ? rowToWorkflow(row) : null;
+}
+function getWorkflowByName(name, db) {
+  const d = db ?? getDatabase();
+  const row = d.query("SELECT * FROM connector_workflows WHERE name = ?").get(name);
+  return row ? rowToWorkflow(row) : null;
+}
+function listWorkflows(db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM connector_workflows ORDER BY name").all().map(rowToWorkflow);
+}
+function deleteWorkflow(id, db) {
+  const d = db ?? getDatabase();
+  return d.run("DELETE FROM connector_workflows WHERE id = ?", [id]).changes > 0;
+}
+var init_workflows = __esm(() => {
+  init_database();
+});
+
+// src/lib/strip.ts
+async function maybeStrip(output, _type = "json") {
+  const config = getLlmConfig();
+  if (!config?.strip)
+    return output;
+  if (!output || output.trim().length === 0)
+    return output;
+  const client = LLMClient.fromConfig();
+  if (!client)
+    return output;
+  try {
+    const result = await client.complete(STRIP_PROMPT, output);
+    return result.content.trim();
+  } catch {
+    return output;
+  }
+}
+var STRIP_PROMPT = `You are a data extraction assistant. Your job is to take raw API output and return ONLY the essential, structured data.
+
+Rules:
+- Return valid JSON only (no markdown, no explanation)
+- Remove pagination metadata, rate limit headers, empty fields, null values
+- Keep all meaningful data fields
+- If the input is already minimal, return it unchanged
+- If input is not JSON, extract key facts as a JSON object
+- Never truncate actual data values`;
+var init_strip = __esm(() => {
+  init_llm();
+});
+
+// src/lib/scheduler.ts
+var exports_scheduler = {};
+__export(exports_scheduler, {
+  triggerJob: () => triggerJob,
+  stopScheduler: () => stopScheduler,
+  startScheduler: () => startScheduler
+});
+import { spawn } from "child_process";
+function cronMatches(cron, d) {
+  const parts = cron.trim().split(/\s+/);
+  if (parts.length !== 5)
+    return false;
+  const [min, hour, dom, mon, dow] = parts;
+  function matches(field, value, min_v, max_v) {
+    if (field === "*")
+      return true;
+    if (field.startsWith("*/")) {
+      const step = parseInt(field.slice(2));
+      return value % step === 0;
+    }
+    if (field.includes("-")) {
+      const [a, b] = field.split("-").map(Number);
+      return value >= a && value <= b;
+    }
+    if (field.includes(",")) {
+      return field.split(",").map(Number).includes(value);
+    }
+    return parseInt(field) === value;
+  }
+  return matches(min, d.getMinutes(), 0, 59) && matches(hour, d.getHours(), 0, 23) && matches(dom, d.getDate(), 1, 31) && matches(mon, d.getMonth() + 1, 1, 12) && matches(dow, d.getDay(), 0, 6);
+}
+async function runConnectorCommand(connector, command, args) {
+  return new Promise((resolve) => {
+    const cmdArgs = [connector, command, ...args, "--format", "json"];
+    const proc = spawn("connectors", ["run", ...cmdArgs], { shell: false });
+    let output = "";
+    proc.stdout.on("data", (d) => {
+      output += d.toString();
+    });
+    proc.stderr.on("data", (d) => {
+      output += d.toString();
+    });
+    proc.on("close", (code) => resolve({ exitCode: code ?? 1, output }));
+    proc.on("error", () => resolve({ exitCode: 1, output: `Failed to spawn connectors run` }));
+    setTimeout(() => {
+      proc.kill();
+      resolve({ exitCode: 124, output: output + `
+[timeout]` });
+    }, 60000);
+  });
+}
+async function executeJob(job, db) {
+  const run = createJobRun(job.id, db);
+  try {
+    const { exitCode, output } = await runConnectorCommand(job.connector, job.command, job.args);
+    const stripped = job.strip ? await maybeStrip(output) : undefined;
+    finishJobRun(run.id, { exit_code: exitCode, raw_output: output, stripped_output: stripped }, db);
+    touchJobLastRun(job.id, db);
+  } catch (e) {
+    finishJobRun(run.id, { exit_code: 1, raw_output: String(e) }, db);
+  }
+}
+function startScheduler(db) {
+  if (_interval)
+    return;
+  _interval = setInterval(async () => {
+    const now2 = new Date;
+    const currentMinute = now2.getMinutes() + now2.getHours() * 60;
+    if (currentMinute === _lastCheckedMinute)
+      return;
+    _lastCheckedMinute = currentMinute;
+    const jobs = listEnabledJobs(db);
+    for (const job of jobs) {
+      if (cronMatches(job.cron, now2)) {
+        executeJob(job, db).catch(() => {});
+      }
+    }
+  }, 30000);
+}
+function stopScheduler() {
+  if (_interval) {
+    clearInterval(_interval);
+    _interval = null;
+    _lastCheckedMinute = -1;
+  }
+}
+async function triggerJob(job, db) {
+  const run = createJobRun(job.id, db);
+  const { exitCode, output } = await runConnectorCommand(job.connector, job.command, job.args);
+  const stripped = job.strip ? await maybeStrip(output) : undefined;
+  finishJobRun(run.id, { exit_code: exitCode, raw_output: output, stripped_output: stripped }, db);
+  touchJobLastRun(job.id, db);
+  return { run_id: run.id, exit_code: exitCode, output: stripped ?? output };
+}
+var _interval = null, _lastCheckedMinute = -1;
+var init_scheduler = __esm(() => {
+  init_jobs();
+  init_strip();
+});
+
+// src/lib/workflow-runner.ts
+import { spawn as spawn2 } from "child_process";
+async function runStep(step, previousOutput) {
+  return new Promise((resolve) => {
+    const args = [...step.args ?? []];
+    if (previousOutput && previousOutput.trim()) {
+      args.push("--input", previousOutput.trim().slice(0, 4096));
+    }
+    const cmdArgs = ["run", step.connector, step.command, ...args, "--format", "json"];
+    const proc = spawn2("connectors", cmdArgs, { shell: false });
+    let output = "";
+    proc.stdout.on("data", (d) => {
+      output += d.toString();
+    });
+    proc.stderr.on("data", (d) => {
+      output += d.toString();
+    });
+    proc.on("close", (code) => resolve({ exitCode: code ?? 1, output }));
+    proc.on("error", () => resolve({ exitCode: 1, output: "Failed to spawn connectors" }));
+    setTimeout(() => {
+      proc.kill();
+      resolve({ exitCode: 124, output: output + `
+[timeout]` });
+    }, 60000);
+  });
+}
+async function runWorkflow(workflow) {
+  const results = [];
+  let previousOutput;
+  let success = true;
+  for (let i = 0;i < workflow.steps.length; i++) {
+    const step = workflow.steps[i];
+    const { exitCode, output } = await runStep(step, previousOutput);
+    const stripped = await maybeStrip(output);
+    results.push({ step: i + 1, connector: step.connector, command: step.command, exit_code: exitCode, output: stripped });
+    if (exitCode !== 0) {
+      success = false;
+      break;
+    }
+    previousOutput = stripped;
+  }
+  return {
+    workflow_id: workflow.id,
+    workflow_name: workflow.name,
+    steps: results,
+    success,
+    final_output: results[results.length - 1]?.output ?? ""
+  };
+}
+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, readFileSync } from "fs";
-import { join, dirname } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join3, dirname } from "path";
 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);
@@ -1888,17 +2707,17 @@ function loadConnectorVersions() {
   versionsLoaded = true;
   const thisDir = dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    join(thisDir, "..", "connectors"),
-    join(thisDir, "..", "..", "connectors")
+    join3(thisDir, "..", "connectors"),
+    join3(thisDir, "..", "..", "connectors")
   ];
-  const connectorsDir = candidates.find((d) => existsSync(d));
+  const connectorsDir = candidates.find((d) => existsSync2(d));
   if (!connectorsDir)
     return;
   for (const connector of CONNECTORS) {
     try {
-      const pkgPath = join(connectorsDir, `connect-${connector.name}`, "package.json");
-      if (existsSync(pkgPath)) {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      const pkgPath = join3(connectorsDir, `connect-${connector.name}`, "package.json");
+      if (existsSync2(pkgPath)) {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
         connector.version = pkg.version || "0.0.0";
       }
     } catch {}
@@ -1906,6 +2725,7 @@ function loadConnectorVersions() {
 }
 var CATEGORIES, CONNECTORS, versionsLoaded = false;
 var init_registry = __esm(() => {
+  init_synonyms();
   CATEGORIES = [
     "AI & ML",
     "Developer Tools",
@@ -2311,6 +3131,13 @@ var init_registry = __esm(() => {
       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",
@@ -6791,13 +7618,6 @@ var init_registry = __esm(() => {
       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",
@@ -9471,23 +10291,28 @@ var require_cli_spinners = __commonJS((exports, module) => {
 });
 
 // src/lib/installer.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
+import { existsSync as existsSync3, cpSync, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, readdirSync, statSync, rmSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveConnectorsDir() {
-  const fromBin = join2(__dirname2, "..", "connectors");
-  if (existsSync2(fromBin))
+  const fromBin = join4(__dirname2, "..", "connectors");
+  if (existsSync3(fromBin))
     return fromBin;
-  const fromSrc = join2(__dirname2, "..", "..", "connectors");
-  if (existsSync2(fromSrc))
+  const fromSrc = join4(__dirname2, "..", "..", "connectors");
+  if (existsSync3(fromSrc))
     return fromSrc;
   return fromBin;
 }
 function getConnectorPath(name) {
   const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  return join2(CONNECTORS_DIR, connectorName);
+  return join4(CONNECTORS_DIR, connectorName);
+}
+function connectorExists(name) {
+  return existsSync3(getConnectorPath(name));
 }
 function installConnector(name, options = {}) {
+  const { targetDir = process.cwd(), overwrite = false } = options;
   if (!/^[a-z0-9-]+$/.test(name)) {
     return {
       connector: name,
@@ -9495,35 +10320,91 @@ function installConnector(name, options = {}) {
       error: `Invalid connector name '${name}'`
     };
   }
+  const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
   const sourcePath = getConnectorPath(name);
-  if (!existsSync2(sourcePath)) {
+  const destDir = join4(targetDir, ".connectors");
+  const destPath = join4(destDir, connectorName);
+  if (!existsSync3(sourcePath)) {
     return {
       connector: name,
       success: false,
       error: `Connector '${name}' not found`
     };
   }
-  return {
-    connector: name,
-    success: true,
-    path: sourcePath
-  };
+  if (existsSync3(destPath) && !overwrite) {
+    return {
+      connector: name,
+      success: false,
+      error: `Already installed. Use --overwrite to replace.`,
+      path: destPath
+    };
+  }
+  try {
+    if (!existsSync3(destDir)) {
+      mkdirSync3(destDir, { recursive: true });
+    }
+    cpSync(sourcePath, destPath, { recursive: true });
+    const homeCredDir = join4(homedir3(), ".connectors", connectorName);
+    if (existsSync3(homeCredDir)) {
+      const filesToCopy = ["credentials.json", "current_profile"];
+      for (const file of filesToCopy) {
+        const src = join4(homeCredDir, file);
+        if (existsSync3(src)) {
+          cpSync(src, join4(destPath, file));
+        }
+      }
+      const profilesDir = join4(homeCredDir, "profiles");
+      if (existsSync3(profilesDir)) {
+        cpSync(profilesDir, join4(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 getInstalledConnectors() {
-  if (!existsSync2(CONNECTORS_DIR)) {
+function updateConnectorsIndex(connectorsDir) {
+  const indexPath = join4(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}
+`;
+  writeFileSync2(indexPath, content);
+}
+function getInstalledConnectors(targetDir = process.cwd()) {
+  const connectorsDir = join4(targetDir, ".connectors");
+  if (!existsSync3(connectorsDir)) {
     return [];
   }
-  return readdirSync(CONNECTORS_DIR).filter((f) => {
-    const fullPath = join2(CONNECTORS_DIR, f);
+  return readdirSync(connectorsDir).filter((f) => {
+    const fullPath = join4(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))
+  const claudeMdPath = join4(connectorPath, "CLAUDE.md");
+  if (!existsSync3(claudeMdPath))
     return null;
-  const raw = readFileSync2(claudeMdPath, "utf-8");
+  const raw = readFileSync3(claudeMdPath, "utf-8");
   return {
     overview: extractSection(raw, "Project Overview"),
     auth: extractSection(raw, "Authentication"),
@@ -9560,8 +10441,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 = join4(targetDir, ".connectors");
+  const connectorPath = join4(connectorsDir, connectorName);
+  if (!existsSync3(connectorPath)) {
+    return false;
+  }
+  rmSync(connectorPath, { recursive: true });
+  updateConnectorsIndex(connectorsDir);
+  return true;
 }
 var __dirname2, CONNECTORS_DIR;
 var init_installer = __esm(() => {
@@ -9569,11 +10458,77 @@ var init_installer = __esm(() => {
   CONNECTORS_DIR = resolveConnectorsDir();
 });
 
+// src/lib/lock.ts
+import { openSync, closeSync, unlinkSync, existsSync as existsSync4, statSync as statSync2 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+import { mkdirSync as mkdirSync4 } from "fs";
+function lockPath(connector) {
+  const dir = join5(homedir4(), ".connectors", `connect-${connector}`);
+  mkdirSync4(dir, { recursive: true });
+  return join5(dir, ".write.lock");
+}
+function isStale(path) {
+  try {
+    const stat = statSync2(path);
+    return Date.now() - stat.mtimeMs > STALE_LOCK_MS;
+  } catch {
+    return false;
+  }
+}
+function tryAcquire(path) {
+  if (existsSync4(path) && isStale(path)) {
+    try {
+      unlinkSync(path);
+    } catch {}
+  }
+  try {
+    const fd = openSync(path, "wx");
+    closeSync(fd);
+    return true;
+  } catch (e) {
+    if (e.code === "EEXIST")
+      return false;
+    throw e;
+  }
+}
+function release(path) {
+  try {
+    unlinkSync(path);
+  } catch {}
+}
+async function withWriteLock(connector, fn) {
+  const path = lockPath(connector);
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (tryAcquire(path)) {
+      try {
+        return await fn();
+      } finally {
+        release(path);
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+  }
+  throw new LockTimeoutError(connector);
+}
+var LOCK_TIMEOUT_MS = 5000, LOCK_RETRY_MS = 100, STALE_LOCK_MS = 30000, LockTimeoutError;
+var init_lock = __esm(() => {
+  LockTimeoutError = class LockTimeoutError extends Error {
+    connector;
+    constructor(connector) {
+      super(`Could not acquire write lock for connector "${connector}" within ${LOCK_TIMEOUT_MS}ms. Another agent may be writing. Try again shortly.`);
+      this.connector = connector;
+      this.name = "LockTimeoutError";
+    }
+  };
+});
+
 // src/server/auth.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync, mkdirSync, readdirSync as readdirSync2, rmSync, statSync as statSync2 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync5, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync3 } from "fs";
 import { randomBytes } from "crypto";
-import { homedir } from "os";
-import { join as join3 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
 function getAuthType(name) {
   const docs = getConnectorDocs(name);
   if (!docs?.auth)
@@ -9587,14 +10542,14 @@ function getAuthType(name) {
 }
 function getConnectorConfigDir(name) {
   const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-  return join3(homedir(), ".connectors", connectorName);
+  return join6(homedir5(), ".connectors", connectorName);
 }
 function getCurrentProfile(name) {
   const configDir = getConnectorConfigDir(name);
-  const currentProfileFile = join3(configDir, "current_profile");
-  if (existsSync3(currentProfileFile)) {
+  const currentProfileFile = join6(configDir, "current_profile");
+  if (existsSync5(currentProfileFile)) {
     try {
-      return readFileSync3(currentProfileFile, "utf-8").trim() || "default";
+      return readFileSync4(currentProfileFile, "utf-8").trim() || "default";
     } catch {
       return "default";
     }
@@ -9606,16 +10561,16 @@ function loadProfileConfig(name) {
   const profile = getCurrentProfile(name);
   let flatConfig = {};
   let dirConfig = {};
-  const profileFile = join3(configDir, "profiles", `${profile}.json`);
-  if (existsSync3(profileFile)) {
+  const profileFile = join6(configDir, "profiles", `${profile}.json`);
+  if (existsSync5(profileFile)) {
     try {
-      flatConfig = JSON.parse(readFileSync3(profileFile, "utf-8"));
+      flatConfig = JSON.parse(readFileSync4(profileFile, "utf-8"));
     } catch {}
   }
-  const profileDirConfig = join3(configDir, "profiles", profile, "config.json");
-  if (existsSync3(profileDirConfig)) {
+  const profileDirConfig = join6(configDir, "profiles", profile, "config.json");
+  if (existsSync5(profileDirConfig)) {
     try {
-      dirConfig = JSON.parse(readFileSync3(profileDirConfig, "utf-8"));
+      dirConfig = JSON.parse(readFileSync4(profileDirConfig, "utf-8"));
     } catch {}
   }
   if (Object.keys(flatConfig).length === 0 && Object.keys(dirConfig).length === 0) {
@@ -9626,14 +10581,24 @@ function loadProfileConfig(name) {
 function loadTokens(name) {
   const configDir = getConnectorConfigDir(name);
   const profile = getCurrentProfile(name);
-  const tokensFile = join3(configDir, "profiles", profile, "tokens.json");
-  if (existsSync3(tokensFile)) {
+  const tokensFile = join6(configDir, "profiles", profile, "tokens.json");
+  if (existsSync5(tokensFile)) {
     try {
-      return JSON.parse(readFileSync3(tokensFile, "utf-8"));
+      return JSON.parse(readFileSync4(tokensFile, "utf-8"));
     } catch {
       return null;
     }
   }
+  const profileConfig = loadProfileConfig(name);
+  if (profileConfig.refreshToken || profileConfig.accessToken) {
+    return {
+      accessToken: profileConfig.accessToken ?? "",
+      refreshToken: profileConfig.refreshToken,
+      expiresAt: profileConfig.expiresAt ?? 0,
+      tokenType: profileConfig.tokenType,
+      scope: profileConfig.scope
+    };
+  }
   return null;
 }
 function getAuthStatus(name) {
@@ -9678,48 +10643,51 @@ function getEnvVars(name) {
   const docs = getConnectorDocs(name);
   return docs?.envVars || [];
 }
-function saveApiKey(name, key, field) {
+async function saveApiKey(name, key, field) {
+  return withWriteLock(name, () => _saveApiKey(name, key, field));
+}
+function _saveApiKey(name, key, field) {
   const configDir = getConnectorConfigDir(name);
   const profile = getCurrentProfile(name);
   const keyField = field || guessKeyField(name);
   if (keyField === "clientId" || keyField === "clientSecret") {
-    const credentialsFile = join3(configDir, "credentials.json");
-    mkdirSync(configDir, { recursive: true });
+    const credentialsFile = join6(configDir, "credentials.json");
+    mkdirSync5(configDir, { recursive: true });
     let creds = {};
-    if (existsSync3(credentialsFile)) {
+    if (existsSync5(credentialsFile)) {
       try {
-        creds = JSON.parse(readFileSync3(credentialsFile, "utf-8"));
+        creds = JSON.parse(readFileSync4(credentialsFile, "utf-8"));
       } catch {}
     }
     creds[keyField] = key;
-    writeFileSync(credentialsFile, JSON.stringify(creds, null, 2));
+    writeFileSync3(credentialsFile, JSON.stringify(creds, null, 2));
     return;
   }
-  const profileFile = join3(configDir, "profiles", `${profile}.json`);
-  const profileDir = join3(configDir, "profiles", profile);
-  if (existsSync3(profileFile)) {
+  const profileFile = join6(configDir, "profiles", `${profile}.json`);
+  const profileDir = join6(configDir, "profiles", profile);
+  if (existsSync5(profileFile)) {
     let config = {};
     try {
-      config = JSON.parse(readFileSync3(profileFile, "utf-8"));
+      config = JSON.parse(readFileSync4(profileFile, "utf-8"));
     } catch {}
     config[keyField] = key;
-    writeFileSync(profileFile, JSON.stringify(config, null, 2));
+    writeFileSync3(profileFile, JSON.stringify(config, null, 2));
     return;
   }
-  if (existsSync3(profileDir)) {
-    const configFile = join3(profileDir, "config.json");
+  if (existsSync5(profileDir)) {
+    const configFile = join6(profileDir, "config.json");
     let config = {};
-    if (existsSync3(configFile)) {
+    if (existsSync5(configFile)) {
       try {
-        config = JSON.parse(readFileSync3(configFile, "utf-8"));
+        config = JSON.parse(readFileSync4(configFile, "utf-8"));
       } catch {}
     }
     config[keyField] = key;
-    writeFileSync(configFile, JSON.stringify(config, null, 2));
+    writeFileSync3(configFile, JSON.stringify(config, null, 2));
     return;
   }
-  mkdirSync(profileDir, { recursive: true });
-  writeFileSync(join3(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
+  mkdirSync5(profileDir, { recursive: true });
+  writeFileSync3(join6(profileDir, "config.json"), JSON.stringify({ [keyField]: key }, null, 2));
 }
 function guessKeyField(name) {
   const docs = getConnectorDocs(name);
@@ -9737,10 +10705,10 @@ function guessKeyField(name) {
 }
 function getOAuthConfig(name) {
   const configDir = getConnectorConfigDir(name);
-  const credentialsFile = join3(configDir, "credentials.json");
-  if (existsSync3(credentialsFile)) {
+  const credentialsFile = join6(configDir, "credentials.json");
+  if (existsSync5(credentialsFile)) {
     try {
-      const creds = JSON.parse(readFileSync3(credentialsFile, "utf-8"));
+      const creds = JSON.parse(readFileSync4(credentialsFile, "utf-8"));
       return { clientId: creds.clientId, clientSecret: creds.clientSecret };
     } catch {}
   }
@@ -9819,12 +10787,15 @@ async function exchangeOAuthCode(name, code, redirectUri) {
 function saveOAuthTokens(name, tokens) {
   const configDir = getConnectorConfigDir(name);
   const profile = getCurrentProfile(name);
-  const profileDir = join3(configDir, "profiles", profile);
-  mkdirSync(profileDir, { recursive: true });
-  const tokensFile = join3(profileDir, "tokens.json");
-  writeFileSync(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
+  const profileDir = join6(configDir, "profiles", profile);
+  mkdirSync5(profileDir, { recursive: true });
+  const tokensFile = join6(profileDir, "tokens.json");
+  writeFileSync3(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 async function refreshOAuthToken(name) {
+  return withWriteLock(name, () => _refreshOAuthToken(name));
+}
+async function _refreshOAuthToken(name) {
   const oauthConfig = getOAuthConfig(name);
   const currentTokens = loadTokens(name);
   if (!oauthConfig.clientId || !oauthConfig.clientSecret) {
@@ -9861,15 +10832,15 @@ async function refreshOAuthToken(name) {
 }
 function listProfiles(name) {
   const configDir = getConnectorConfigDir(name);
-  const profilesDir = join3(configDir, "profiles");
-  if (!existsSync3(profilesDir))
+  const profilesDir = join6(configDir, "profiles");
+  if (!existsSync5(profilesDir))
     return ["default"];
   const seen = new Set;
   try {
     const entries = readdirSync2(profilesDir);
     for (const entry of entries) {
-      const fullPath = join3(profilesDir, entry);
-      const stat = statSync2(fullPath);
+      const fullPath = join6(profilesDir, entry);
+      const stat = statSync3(fullPath);
       if (stat.isDirectory()) {
         seen.add(entry);
       } else if (entry.endsWith(".json")) {
@@ -9882,25 +10853,25 @@ function listProfiles(name) {
 }
 function switchProfile(name, profile) {
   const configDir = getConnectorConfigDir(name);
-  mkdirSync(configDir, { recursive: true });
-  writeFileSync(join3(configDir, "current_profile"), profile);
+  mkdirSync5(configDir, { recursive: true });
+  writeFileSync3(join6(configDir, "current_profile"), profile);
 }
 function deleteProfile(name, profile) {
   if (profile === "default")
     return false;
   const configDir = getConnectorConfigDir(name);
-  const profilesDir = join3(configDir, "profiles");
-  const profileFile = join3(profilesDir, `${profile}.json`);
-  if (existsSync3(profileFile)) {
-    rmSync(profileFile);
+  const profilesDir = join6(configDir, "profiles");
+  const profileFile = join6(profilesDir, `${profile}.json`);
+  if (existsSync5(profileFile)) {
+    rmSync2(profileFile);
     if (getCurrentProfile(name) === profile) {
       switchProfile(name, "default");
     }
     return true;
   }
-  const profileDir = join3(profilesDir, profile);
-  if (existsSync3(profileDir)) {
-    rmSync(profileDir, { recursive: true });
+  const profileDir = join6(profilesDir, profile);
+  if (existsSync5(profileDir)) {
+    rmSync2(profileDir, { recursive: true });
     if (getCurrentProfile(name) === profile) {
       switchProfile(name, "default");
     }
@@ -9911,6 +10882,7 @@ function deleteProfile(name, profile) {
 var FETCH_TIMEOUT = 1e4, oauthStateStore, GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth", GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token", GOOGLE_SCOPES;
 var init_auth = __esm(() => {
   init_installer();
+  init_lock();
   oauthStateStore = new Map;
   GOOGLE_SCOPES = {
     gmail: [
@@ -9952,15 +10924,222 @@ 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);
+}
+function isAgentConflict(result) {
+  return result.conflict === true;
+}
+function registerAgent(input, db) {
+  const d = db ?? getDatabase();
+  const normalizedName = input.name.trim().toLowerCase();
+  const existing = getAgentByName(normalizedName, d);
+  if (existing) {
+    const lastSeenMs = new Date(existing.last_seen_at).getTime();
+    const isActive = Date.now() - lastSeenMs < AGENT_ACTIVE_WINDOW_MS;
+    const sameSession = input.session_id && existing.session_id && input.session_id === existing.session_id;
+    const differentSession = input.session_id && existing.session_id && input.session_id !== existing.session_id;
+    if (isActive && differentSession) {
+      const minutesAgo = Math.round((Date.now() - lastSeenMs) / 60000);
+      return {
+        conflict: true,
+        existing_id: existing.id,
+        existing_name: existing.name,
+        last_seen_at: existing.last_seen_at,
+        session_hint: existing.session_id ? existing.session_id.slice(0, 8) : null,
+        working_dir: null,
+        message: `Agent "${normalizedName}" is already active (last seen ${minutesAgo}m ago). Pass session_id="${existing.session_id}" to reclaim it, or choose a different name.`
+      };
+    }
+    const updates = ["last_seen_at = ?"];
+    const params = [now()];
+    if (input.session_id && !sameSession) {
+      updates.push("session_id = ?");
+      params.push(input.session_id);
+    }
+    params.push(existing.id);
+    d.run(`UPDATE agents SET ${updates.join(", ")} WHERE id = ?`, params);
+    return getAgent(existing.id, d);
+  }
+  const id = shortUuid2();
+  const ts = now();
+  d.run(`INSERT INTO agents (id, name, session_id, role, last_seen_at, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`, [id, normalizedName, input.session_id ?? null, input.role ?? "agent", ts, ts]);
+  return getAgent(id, d);
+}
+function getAgent(id, db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM agents WHERE id = ?").get(id);
+}
+function getAgentByName(name, db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM agents WHERE LOWER(name) = ?").get(name.trim().toLowerCase());
+}
+function listAgents(db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM agents ORDER BY name").all();
+}
+function deleteAgent(id, db) {
+  const d = db ?? getDatabase();
+  return d.run("DELETE FROM agents WHERE id = ?", [id]).changes > 0;
+}
+var AGENT_ACTIVE_WINDOW_MS;
+var init_agents = __esm(() => {
+  init_database();
+  AGENT_ACTIVE_WINDOW_MS = 30 * 60 * 1000;
+});
+
+// src/db/rate.ts
+function ensureRateTable(db) {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_rate_usage (
+      agent_id TEXT NOT NULL,
+      connector TEXT NOT NULL,
+      window_start TEXT NOT NULL,
+      call_count INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (agent_id, connector, window_start)
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_rate_usage_window ON connector_rate_usage(connector, window_start)`);
+}
+function countActiveAgents(db) {
+  const cutoff = new Date(Date.now() - AGENT_ACTIVE_WINDOW_MS2).toISOString();
+  const row = db.query("SELECT COUNT(*) as count FROM agents WHERE last_seen_at > ?").get(cutoff);
+  return Math.max(1, row?.count ?? 1);
+}
+function currentWindowStart() {
+  const now3 = Date.now();
+  const windowMs = WINDOW_SECONDS * 1000;
+  return new Date(Math.floor(now3 / windowMs) * windowMs).toISOString();
+}
+function checkRateBudget(agentId, connector, connectorLimit, consume = true, db) {
+  const d = db ?? getDatabase();
+  ensureRateTable(d);
+  const activeAgents = countActiveAgents(d);
+  const budget = Math.max(1, Math.floor(connectorLimit / activeAgents));
+  const windowStart = currentWindowStart();
+  const windowMs = WINDOW_SECONDS * 1000;
+  const windowEnd = new Date(Math.floor(Date.now() / windowMs) * windowMs + windowMs);
+  const windowResetsIn = windowEnd.getTime() - Date.now();
+  const row = d.query("SELECT call_count FROM connector_rate_usage WHERE agent_id = ? AND connector = ? AND window_start = ?").get(agentId, connector, windowStart);
+  const used = row?.call_count ?? 0;
+  if (used >= budget) {
+    return {
+      exceeded: true,
+      connector,
+      agent_id: agentId,
+      budget,
+      used,
+      active_agents: activeAgents,
+      window_resets_in_ms: windowResetsIn,
+      message: `Rate budget exceeded for "${connector}" (${used}/${budget} calls used, ${activeAgents} active agent${activeAgents === 1 ? "" : "s"} sharing limit of ${connectorLimit}/min). Resets in ${Math.ceil(windowResetsIn / 1000)}s.`
+    };
+  }
+  if (consume) {
+    d.run(`INSERT INTO connector_rate_usage (agent_id, connector, window_start, call_count)
+       VALUES (?, ?, ?, 1)
+       ON CONFLICT(agent_id, connector, window_start) DO UPDATE SET call_count = call_count + 1`, [agentId, connector, windowStart]);
+  }
+  return {
+    connector,
+    agent_id: agentId,
+    limit: connectorLimit,
+    active_agents: activeAgents,
+    budget,
+    used: consume ? used + 1 : used,
+    remaining: consume ? budget - used - 1 : budget - used,
+    window_start: windowStart,
+    window_resets_in_ms: windowResetsIn
+  };
+}
+function getRateBudget(agentId, connector, connectorLimit, db) {
+  return checkRateBudget(agentId, connector, connectorLimit, false, db);
+}
+var AGENT_ACTIVE_WINDOW_MS2, WINDOW_SECONDS = 60;
+var init_rate = __esm(() => {
+  init_database();
+  AGENT_ACTIVE_WINDOW_MS2 = 30 * 60 * 1000;
+});
+
 // src/server/serve.ts
 var exports_serve = {};
 __export(exports_serve, {
   startServer: () => startServer
 });
-import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join5, dirname as dirname4, extname, basename } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync6 } from "fs";
+import { join as join8, dirname as dirname4, extname, basename } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir6 } from "os";
 function logActivity(action, connector, detail) {
   activityLog.unshift({ action, connector, timestamp: Date.now(), detail });
   if (activityLog.length > MAX_ACTIVITY_LOG) {
@@ -9971,20 +11150,20 @@ function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname4(fileURLToPath4(import.meta.url));
-    candidates.push(join5(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join5(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join8(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join8(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname4(process.argv[1]);
-    candidates.push(join5(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join5(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join8(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join8(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join5(process.cwd(), "dashboard", "dist"));
+  candidates.push(join8(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync5(candidate))
+    if (existsSync7(candidate))
       return candidate;
   }
-  return join5(process.cwd(), "dashboard", "dist");
+  return join8(process.cwd(), "dashboard", "dist");
 }
 function json(data, status = 200, port) {
   return new Response(JSON.stringify(data), {
@@ -9996,6 +11175,18 @@ function json(data, status = 200, port) {
     }
   });
 }
+async function jsonStripped(data, status = 200, port) {
+  const raw = JSON.stringify(data);
+  const body = await maybeStrip(raw);
+  return new Response(body, {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": port ? `http://localhost:${port}` : "*",
+      ...SECURITY_HEADERS
+    }
+  });
+}
 function htmlResponse(content, status = 200) {
   return new Response(content, {
     status,
@@ -10057,7 +11248,7 @@ function oauthPage(type, title, message, hint, extra) {
   </body></html>`;
 }
 function serveStaticFile(filePath) {
-  if (!existsSync5(filePath))
+  if (!existsSync7(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -10081,7 +11272,7 @@ async function startServer(requestedPort, options) {
   const shouldOpen = options?.open ?? true;
   loadConnectorVersions();
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync5(dashboardDir);
+  const dashboardExists = existsSync7(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -10110,10 +11301,10 @@ Dashboard not found at: ${dashboardDir}`);
         const fields = fieldsParam ? new Set(fieldsParam.split(",").map((f) => f.trim())) : null;
         const data = getAllConnectorsWithAuth();
         if (compact) {
-          return json(data.map((c) => ({ name: c.name, category: c.category, installed: c.installed })), 200, port);
+          return jsonStripped(data.map((c) => ({ name: c.name, category: c.category, installed: c.installed })), 200, port);
         }
         if (fields) {
-          return json(data.map((c) => {
+          return jsonStripped(data.map((c) => {
             const out = {};
             for (const f of fields) {
               if (f in c)
@@ -10122,7 +11313,7 @@ Dashboard not found at: ${dashboardDir}`);
             return out;
           }), 200, port);
         }
-        return json(data, 200, port);
+        return jsonStripped(data, 200, port);
       }
       const singleMatch = path.match(/^\/api\/connectors\/([^/]+)$/);
       if (singleMatch && method === "GET") {
@@ -10156,7 +11347,7 @@ Dashboard not found at: ${dashboardDir}`);
           const body = await req.json();
           if (!body.key)
             return json({ error: "Missing 'key' in request body" }, 400, port);
-          saveApiKey(name, body.key, body.field);
+          await saveApiKey(name, body.key, body.field);
           logActivity("key_saved", name, body.field ? `Field: ${body.field}` : undefined);
           return json({ success: true }, 200, port);
         } catch (e) {
@@ -10201,7 +11392,10 @@ Dashboard not found at: ${dashboardDir}`);
         if (!isValidConnectorName(name))
           return json({ error: "Invalid connector name" }, 400, port);
         try {
-          removeConnector(name);
+          const removed = removeConnector(name);
+          if (!removed) {
+            return json({ error: `Connector '${name}' is not installed` }, 404, port);
+          }
           logActivity("uninstalled", name);
           return json({ success: true, name }, 200, port);
         } catch (e) {
@@ -10227,6 +11421,167 @@ 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)
+          return json({ configured: false }, 200, port);
+        return json({ configured: true, provider: config.provider, model: config.model, key: maskKey(config.api_key), strip: config.strip }, 200, port);
+      }
+      if (path === "/api/llm" && method === "POST") {
+        const body = await req.json().catch(() => ({}));
+        const validProviders = ["cerebras", "groq", "openai", "anthropic"];
+        const provider = body.provider;
+        if (!provider || !validProviders.includes(provider))
+          return json({ error: "provider must be one of: " + validProviders.join(", ") }, 400, port);
+        const api_key = body.api_key;
+        if (!api_key)
+          return json({ error: "api_key is required" }, 400, port);
+        const model = body.model || getLlmConfig()?.model || "qwen-3-32b";
+        const strip = typeof body.strip === "boolean" ? body.strip : getLlmConfig()?.strip ?? false;
+        saveLlmConfig({ provider, model, api_key, strip });
+        return json({ success: true, provider, model, strip }, 200, port);
+      }
+      if (path === "/api/llm/test" && method === "POST") {
+        const config = getLlmConfig();
+        if (!config)
+          return json({ error: "No LLM configured" }, 400, port);
+        try {
+          const client = new LLMClient(config);
+          const result = await client.complete('Respond with exactly: {"status":"ok"}', "ping");
+          return json({ success: true, provider: result.provider, model: result.model, latency_ms: result.latency_ms, response: result.content }, 200, port);
+        } catch (e) {
+          return json({ success: false, error: e instanceof Error ? e.message : String(e) }, 500, port);
+        }
+      }
+      if (path === "/api/jobs" && method === "GET") {
+        return json(listJobs(getDatabase2()), 200, port);
+      }
+      if (path === "/api/jobs" && method === "POST") {
+        const body = await req.json().catch(() => ({}));
+        if (!body.name || !body.connector || !body.command || !body.cron)
+          return json({ error: "name, connector, command, cron required" }, 400, port);
+        const job = createJob({ name: body.name, connector: body.connector, command: body.command, args: body.args ?? [], cron: body.cron, strip: !!body.strip }, getDatabase2());
+        return json(job, 201, port);
+      }
+      const jobMatch = path.match(/^\/api\/jobs\/([^/]+)$/);
+      if (jobMatch) {
+        const db = getDatabase2();
+        const job = getJobByName(jobMatch[1]) ?? getDatabase2().query("SELECT * FROM connector_jobs WHERE id = ?").get(jobMatch[1]);
+        if (!job && method !== "DELETE")
+          return json({ error: "Job not found" }, 404, port);
+        if (method === "GET")
+          return json(listJobRuns(job.id, 20, db), 200, port);
+        if (method === "DELETE") {
+          const j = getJobByName(jobMatch[1], db);
+          if (!j)
+            return json({ error: "Job not found" }, 404, port);
+          deleteJob(j.id, db);
+          return json({ success: true }, 200, port);
+        }
+        if (method === "PATCH") {
+          const body = await req.json().catch(() => ({}));
+          const j = getJobByName(jobMatch[1], db);
+          const updated = updateJob(j.id, { enabled: typeof body.enabled === "boolean" ? body.enabled : undefined, strip: typeof body.strip === "boolean" ? body.strip : undefined }, db);
+          return json(updated, 200, port);
+        }
+      }
+      const jobRunMatch = path.match(/^\/api\/jobs\/([^/]+)\/run$/);
+      if (jobRunMatch && method === "POST") {
+        const db = getDatabase2();
+        const job = getJobByName(jobRunMatch[1], db);
+        if (!job)
+          return json({ error: "Job not found" }, 404, port);
+        const result = await triggerJob(job, db);
+        return json(result, 200, port);
+      }
+      if (path === "/api/workflows" && method === "GET") {
+        return json(listWorkflows(getDatabase2()), 200, port);
+      }
+      if (path === "/api/workflows" && method === "POST") {
+        const body = await req.json().catch(() => ({}));
+        if (!body.name || !body.steps)
+          return json({ error: "name and steps required" }, 400, port);
+        const wf = createWorkflow({ name: body.name, steps: body.steps }, getDatabase2());
+        return json(wf, 201, port);
+      }
+      const wfMatch = path.match(/^\/api\/workflows\/([^/]+)$/);
+      if (wfMatch) {
+        const db = getDatabase2();
+        const wf = getWorkflowByName(wfMatch[1], db);
+        if (!wf)
+          return json({ error: "Workflow not found" }, 404, port);
+        if (method === "GET")
+          return json(wf, 200, port);
+        if (method === "DELETE") {
+          deleteWorkflow(wf.id, db);
+          return json({ success: true }, 200, port);
+        }
+      }
+      const wfRunMatch = path.match(/^\/api\/workflows\/([^/]+)\/run$/);
+      if (wfRunMatch && method === "POST") {
+        const wf = getWorkflowByName(wfRunMatch[1], getDatabase2());
+        if (!wf)
+          return json({ error: "Workflow not found" }, 404, port);
+        const result = await runWorkflow(wf);
+        return json(result, 200, port);
+      }
+      if (path === "/api/agents" && method === "GET") {
+        return json(listAgents(), 200, port);
+      }
+      if (path === "/api/agents/register" && method === "POST") {
+        const body = await req.json().catch(() => ({}));
+        const name = typeof body.name === "string" ? body.name : null;
+        if (!name)
+          return json({ error: "name is required" }, 400, port);
+        const result = registerAgent({
+          name,
+          session_id: typeof body.session_id === "string" ? body.session_id : undefined,
+          role: typeof body.role === "string" ? body.role : undefined
+        });
+        if (isAgentConflict(result))
+          return json(result, 409, port);
+        return json(result, 200, port);
+      }
+      if (path.startsWith("/api/agents/") && method === "DELETE") {
+        const agentName = path.slice("/api/agents/".length);
+        const agent = getAgentByName(agentName);
+        if (!agent)
+          return json({ error: "Agent not found" }, 404, port);
+        deleteAgent(agent.id);
+        return json({ success: true }, 200, port);
+      }
+      const rateMatch = path.match(/^\/api\/rate\/([^/]+)\/([^/]+)$/);
+      if (rateMatch && method === "GET") {
+        const [, agentId, connector] = rateMatch;
+        const limit = parseInt(url2.searchParams.get("limit") || "60", 10);
+        const consume = url2.searchParams.get("consume") === "true";
+        const result = consume ? checkRateBudget(agentId, connector, limit) : getRateBudget(agentId, connector, limit);
+        return json(result, 200, port);
+      }
       const profilesMatch = path.match(/^\/api\/connectors\/([^/]+)\/profiles$/);
       if (profilesMatch && method === "GET") {
         const name = profilesMatch[1];
@@ -10234,12 +11589,12 @@ Dashboard not found at: ${dashboardDir}`);
           return json({ error: "Invalid connector name" }, 400, port);
         try {
           const profiles = listProfiles(name);
-          const configDir = join5(homedir2(), ".connectors", name.startsWith("connect-") ? name : `connect-${name}`);
-          const currentProfileFile = join5(configDir, "current_profile");
+          const configDir = join8(homedir6(), ".connectors", name.startsWith("connect-") ? name : `connect-${name}`);
+          const currentProfileFile = join8(configDir, "current_profile");
           let current = "default";
-          if (existsSync5(currentProfileFile)) {
+          if (existsSync7(currentProfileFile)) {
             try {
-              current = readFileSync4(currentProfileFile, "utf-8").trim() || "default";
+              current = readFileSync5(currentProfileFile, "utf-8").trim() || "default";
             } catch {}
           }
           return json({ current, profiles }, 200, port);
@@ -10286,16 +11641,16 @@ Dashboard not found at: ${dashboardDir}`);
       }
       if (path === "/api/export" && method === "GET") {
         try {
-          const connectDir = join5(homedir2(), ".connectors");
+          const connectDir = join8(homedir6(), ".connectors");
           const result = {};
-          if (existsSync5(connectDir)) {
+          if (existsSync7(connectDir)) {
             const entries = readdirSync3(connectDir, { withFileTypes: true });
             for (const entry of entries) {
               if (!entry.isDirectory() || !entry.name.startsWith("connect-"))
                 continue;
               const connectorName = entry.name.replace(/^connect-/, "");
-              const profilesDir = join5(connectDir, entry.name, "profiles");
-              if (!existsSync5(profilesDir))
+              const profilesDir = join8(connectDir, entry.name, "profiles");
+              if (!existsSync7(profilesDir))
                 continue;
               const profiles = {};
               const profileEntries = readdirSync3(profilesDir, { withFileTypes: true });
@@ -10303,15 +11658,15 @@ Dashboard not found at: ${dashboardDir}`);
                 if (pEntry.isFile() && pEntry.name.endsWith(".json")) {
                   const profileName = basename(pEntry.name, ".json");
                   try {
-                    const config = JSON.parse(readFileSync4(join5(profilesDir, pEntry.name), "utf-8"));
+                    const config = JSON.parse(readFileSync5(join8(profilesDir, pEntry.name), "utf-8"));
                     profiles[profileName] = config;
                   } catch {}
                 }
                 if (pEntry.isDirectory()) {
-                  const configPath = join5(profilesDir, pEntry.name, "config.json");
-                  if (existsSync5(configPath)) {
+                  const configPath = join8(profilesDir, pEntry.name, "config.json");
+                  if (existsSync7(configPath)) {
                     try {
-                      const config = JSON.parse(readFileSync4(configPath, "utf-8"));
+                      const config = JSON.parse(readFileSync5(configPath, "utf-8"));
                       profiles[pEntry.name] = config;
                     } catch {}
                   }
@@ -10346,20 +11701,20 @@ Dashboard not found at: ${dashboardDir}`);
             return json({ error: "Invalid import format: missing 'connectors' object" }, 400, port);
           }
           let imported = 0;
-          const connectDir = join5(homedir2(), ".connectors");
+          const connectDir = join8(homedir6(), ".connectors");
           for (const [connectorName, data] of Object.entries(body.connectors)) {
             if (!isValidConnectorName(connectorName))
               continue;
             if (!data.profiles || typeof data.profiles !== "object")
               continue;
-            const connectorDir = join5(connectDir, `connect-${connectorName}`);
-            const profilesDir = join5(connectorDir, "profiles");
+            const connectorDir = join8(connectDir, `connect-${connectorName}`);
+            const profilesDir = join8(connectorDir, "profiles");
             for (const [profileName, config] of Object.entries(data.profiles)) {
               if (!config || typeof config !== "object")
                 continue;
-              mkdirSync2(profilesDir, { recursive: true });
-              const profileFile = join5(profilesDir, `${profileName}.json`);
-              writeFileSync2(profileFile, JSON.stringify(config, null, 2));
+              mkdirSync6(profilesDir, { recursive: true });
+              const profileFile = join8(profilesDir, `${profileName}.json`);
+              writeFileSync4(profileFile, JSON.stringify(config, null, 2));
               imported++;
             }
           }
@@ -10414,12 +11769,12 @@ Dashboard not found at: ${dashboardDir}`);
       }
       if (dashboardExists && (method === "GET" || method === "HEAD")) {
         if (path !== "/") {
-          const filePath = join5(dashboardDir, path);
+          const filePath = join8(dashboardDir, path);
           const res2 = serveStaticFile(filePath);
           if (res2)
             return res2;
         }
-        const indexPath = join5(dashboardDir, "index.html");
+        const indexPath = join8(dashboardDir, "index.html");
         const res = serveStaticFile(indexPath);
         if (res)
           return res;
@@ -10433,6 +11788,9 @@ Dashboard not found at: ${dashboardDir}`);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
+  const { startScheduler: startScheduler2 } = await Promise.resolve().then(() => (init_scheduler(), exports_scheduler));
+  const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+  startScheduler2(getDatabase2());
   const url = `http://localhost:${port}`;
   console.log(`Connectors Dashboard running at ${url}`);
   if (shouldOpen) {
@@ -10445,6 +11803,14 @@ Dashboard not found at: ${dashboardDir}`);
 }
 var activityLog, MAX_ACTIVITY_LOG = 100, MIME_TYPES, SECURITY_HEADERS, MAX_BODY_SIZE;
 var init_serve = __esm(() => {
+  init_agents();
+  init_rate();
+  init_strip();
+  init_llm();
+  init_jobs();
+  init_workflows();
+  init_scheduler();
+  init_workflow_runner();
   init_registry();
   init_installer();
   init_auth();
@@ -10489,6 +11855,101 @@ var {
 
 // src/cli/index.tsx
 import chalk2 from "chalk";
+// package.json
+var package_default = {
+  name: "@hasna/connectors",
+  version: "1.3.5",
+  description: "Open source connector library - Install API connectors with a single command",
+  type: "module",
+  bin: {
+    connectors: "./bin/index.js",
+    "connectors-mcp": "./bin/mcp.js",
+    "connectors-serve": "./bin/serve.js"
+  },
+  files: [
+    "bin/",
+    "dist/",
+    "dashboard/dist/",
+    "connectors/",
+    "README.md"
+  ],
+  exports: {
+    ".": {
+      import: "./dist/index.js",
+      types: "./dist/index.d.ts"
+    }
+  },
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  scripts: {
+    build: "cd dashboard && bun run build && cd .. && bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk --external conf && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/server/index.ts --outfile ./bin/serve.js --target bun && bun build ./src/index.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --outDir ./dist",
+    "build:dashboard": "cd dashboard && bun run build",
+    postinstall: '[ "$SKIP_DASHBOARD" = "1" ] || [ ! -f dashboard/package.json ] || [ -d dashboard/node_modules ] || (cd dashboard && bun install)',
+    dev: "bun run ./src/cli/index.tsx",
+    typecheck: "tsc --noEmit",
+    test: "bun test",
+    "sdk:build": "cd sdk && bun run build",
+    prepublishOnly: "bun test && bun run build"
+  },
+  keywords: [
+    "connectors",
+    "api",
+    "cli",
+    "typescript",
+    "bun",
+    "figma",
+    "stripe",
+    "github",
+    "openai",
+    "mcp",
+    "model-context-protocol"
+  ],
+  author: "Hasna",
+  license: "Apache-2.0",
+  devDependencies: {
+    "@types/bun": "latest",
+    "@types/react": "^18.2.0",
+    "ink-testing-library": "^4.0.0",
+    typescript: "^5"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    chalk: "^5.3.0",
+    commander: "^12.1.0",
+    conf: "^13.0.1",
+    "fast-xml-parser": "^5.5.3",
+    ink: "^5.0.1",
+    "ink-select-input": "^6.0.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    open: "^11.0.0",
+    react: "^18.2.0",
+    zod: "3"
+  },
+  engines: {
+    bun: ">=1.0.0"
+  },
+  publishConfig: {
+    registry: "https://registry.npmjs.org",
+    access: "public"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/hasna/connectors.git"
+  },
+  homepage: "https://github.com/hasna/connectors#readme",
+  bugs: {
+    url: "https://github.com/hasna/connectors/issues"
+  }
+};
+
+// src/cli/index.tsx
+init_llm();
+init_jobs();
+init_workflows();
+init_scheduler();
+init_workflow_runner();
+init_database();
 
 // src/cli/components/App.tsx
 import { useState as useState7 } from "react";
@@ -11962,9 +13423,9 @@ function App({ initialConnectors, overwrite = false }) {
 init_registry();
 init_installer();
 init_auth();
-import { readdirSync as readdirSync4, existsSync as existsSync6, statSync as statSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join6, relative } from "path";
+import { readdirSync as readdirSync4, existsSync as existsSync8, statSync as statSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join9, relative } from "path";
 
 // src/lib/test-endpoints.ts
 var TEST_ENDPOINTS = {
@@ -12165,17 +13626,17 @@ var TEST_ENDPOINTS = {
 import { createInterface } from "readline";
 
 // src/lib/runner.ts
-import { existsSync as existsSync4 } from "fs";
-import { join as join4, dirname as dirname3 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { spawn } from "child_process";
+import { spawn as spawn3 } from "child_process";
 var __dirname3 = dirname3(fileURLToPath3(import.meta.url));
 function resolveConnectorsDir2() {
-  const fromBin = join4(__dirname3, "..", "connectors");
-  if (existsSync4(fromBin))
+  const fromBin = join7(__dirname3, "..", "connectors");
+  if (existsSync6(fromBin))
     return fromBin;
-  const fromSrc = join4(__dirname3, "..", "..", "connectors");
-  if (existsSync4(fromSrc))
+  const fromSrc = join7(__dirname3, "..", "..", "connectors");
+  if (existsSync6(fromSrc))
     return fromSrc;
   return fromBin;
 }
@@ -12215,13 +13676,13 @@ function buildEnvWithCredentials(connectorName, baseEnv) {
 }
 function getConnectorCliPath(name) {
   const safeName = name.replace(/[^a-z0-9-]/g, "");
-  const connectorDir = join4(CONNECTORS_DIR2, `connect-${safeName}`);
-  const cliPath = join4(connectorDir, "src", "cli", "index.ts");
-  if (existsSync4(cliPath))
+  const connectorDir = join7(CONNECTORS_DIR2, `connect-${safeName}`);
+  const cliPath = join7(connectorDir, "src", "cli", "index.ts");
+  if (existsSync6(cliPath))
     return cliPath;
   return null;
 }
-function runConnectorCommand(name, args, timeoutMs = 30000) {
+function runConnectorCommand2(name, args, timeoutMs = 30000) {
   const cliPath = getConnectorCliPath(name);
   if (!cliPath) {
     return Promise.resolve({
@@ -12232,7 +13693,7 @@ function runConnectorCommand(name, args, timeoutMs = 30000) {
     });
   }
   return new Promise((resolve) => {
-    const proc = spawn("bun", ["run", cliPath, ...args], {
+    const proc = spawn3("bun", ["run", cliPath, ...args], {
       timeout: timeoutMs,
       env: buildEnvWithCredentials(name, process.env),
       stdio: ["pipe", "pipe", "pipe"]
@@ -12268,7 +13729,7 @@ async function getConnectorOperations(name) {
   if (!cliPath) {
     return { commands: [], helpText: "", hasCli: false };
   }
-  const result = await runConnectorCommand(name, ["--help"]);
+  const result = await runConnectorCommand2(name, ["--help"]);
   const helpText = result.stdout || result.stderr;
   const commands = [];
   const lines = helpText.split(`
@@ -12292,7 +13753,7 @@ async function getConnectorOperations(name) {
   return { commands, helpText, hasCli: true };
 }
 async function getConnectorCommandHelp(name, command) {
-  const result = await runConnectorCommand(name, [command, "--help"]);
+  const result = await runConnectorCommand2(name, [command, "--help"]);
   return result.stdout || result.stderr;
 }
 
@@ -12309,7 +13770,7 @@ var PRESETS = {
   commerce: { description: "Commerce and finance", connectors: ["stripe", "shopify", "revolut", "mercury", "pandadoc"] }
 };
 var program2 = new Command;
-program2.name("connectors").description("Install API connectors for your project").version("1.3.2").enablePositionalOptions();
+program2.name("connectors").description("Install API connectors for your project").version(package_default.version).enablePositionalOptions();
 program2.command("interactive", { isDefault: true }).alias("i").description("Interactive connector browser").action(() => {
   if (!isTTY) {
     console.log(`Non-interactive environment detected. Use a subcommand:
@@ -12330,8 +13791,8 @@ Run 'connectors --help' for full usage.`);
 function listFilesRecursive(dir, base = dir) {
   const files = [];
   for (const entry of readdirSync4(dir)) {
-    const fullPath = join6(dir, entry);
-    if (statSync3(fullPath).isDirectory()) {
+    const fullPath = join9(dir, entry);
+    if (statSync4(fullPath).isDirectory()) {
       files.push(...listFilesRecursive(fullPath, base));
     } else {
       files.push(relative(base, fullPath));
@@ -12339,7 +13800,7 @@ function listFilesRecursive(dir, base = dir) {
   }
   return files;
 }
-program2.command("install").alias("add").argument("[connectors...]", "Connectors to verify").option("-c, --category <category>", "Verify all connectors in a category").option("--preset <preset>", "Verify a preset bundle (e.g. ai, fullstack, google)").option("--json", "Output results as JSON", false).description("Verify connectors are available in the global package").action((connectors, options) => {
+program2.command("install").alias("add").argument("[connectors...]", "Connectors to install").option("-o, --overwrite", "Overwrite existing connectors", false).option("-d, --dry-run", "Preview what would be installed without making changes", false).option("-c, --category <category>", "Install all connectors in a category").option("--preset <preset>", "Install a preset bundle (e.g. ai, fullstack, google)").option("--json", "Output results as JSON", false).description("Install one or more connectors").action((connectors, options) => {
   if (options.category) {
     const category = CATEGORIES.find((c) => c.toLowerCase() === options.category.toLowerCase());
     if (!category) {
@@ -12352,7 +13813,8 @@ program2.command("install").alias("add").argument("[connectors...]", "Connectors
       process.exit(1);
       return;
     }
-    connectors.push(...getConnectorsByCategory(category).map((c) => c.name));
+    const categoryConnectors = getConnectorsByCategory(category).map((c) => c.name);
+    connectors.push(...categoryConnectors);
   }
   if (options.preset) {
     const preset = PRESETS[options.preset.toLowerCase()];
@@ -12370,25 +13832,133 @@ program2.command("install").alias("add").argument("[connectors...]", "Connectors
   }
   if (connectors.length === 0) {
     if (!isTTY) {
-      console.error("Error: specify connectors to verify. Example: connectors install figma stripe");
+      console.error("Error: specify connectors to install. Example: connectors install figma stripe");
       process.exit(1);
     }
     render(/* @__PURE__ */ jsxDEV7(App, {}, undefined, false, undefined, this));
     return;
   }
-  const results = connectors.map((name) => installConnector(name));
+  if (options.dryRun) {
+    const installed = getInstalledConnectors();
+    const destDir = join9(process.cwd(), ".connectors");
+    const actions = [];
+    for (const name of connectors) {
+      if (!/^[a-z0-9-]+$/.test(name)) {
+        actions.push({ connector: name, action: "error", reason: `Invalid connector name '${name}'` });
+        continue;
+      }
+      const meta = getConnector(name);
+      if (!meta) {
+        actions.push({ connector: name, action: "error", reason: `Connector '${name}' not found in registry` });
+        continue;
+      }
+      if (!connectorExists(name)) {
+        actions.push({ connector: name, action: "error", reason: `Connector '${name}' source files not found` });
+        continue;
+      }
+      const connectorDirName = name.startsWith("connect-") ? name : `connect-${name}`;
+      const sourcePath = getConnectorPath(name);
+      const destPath = join9(destDir, connectorDirName);
+      const alreadyInstalled = installed.includes(name);
+      const files = listFilesRecursive(sourcePath);
+      const importLine = `export * as ${name} from './${connectorDirName}/src/index.js';`;
+      if (alreadyInstalled && !options.overwrite) {
+        actions.push({
+          connector: name,
+          action: "skip",
+          reason: "Already installed. Use --overwrite to replace.",
+          sourcePath,
+          destPath
+        });
+      } else {
+        actions.push({
+          connector: name,
+          action: alreadyInstalled ? "overwrite" : "install",
+          sourcePath,
+          destPath,
+          files,
+          importLine
+        });
+      }
+    }
+    if (options.json) {
+      console.log(JSON.stringify({ dryRun: true, actions }, null, 2));
+      process.exit(actions.every((a) => a.action !== "error") ? 0 : 1);
+      return;
+    }
+    console.log(chalk2.bold(`
+Dry run \u2014 no changes will be made
+`));
+    for (const a of actions) {
+      if (a.action === "error") {
+        console.log(chalk2.red(`  \u2717 ${a.connector}: ${a.reason}`));
+        continue;
+      }
+      if (a.action === "skip") {
+        console.log(chalk2.yellow(`  \u2298 ${a.connector}: ${a.reason}`));
+        continue;
+      }
+      const actionLabel = a.action === "overwrite" ? chalk2.yellow("overwrite") : chalk2.green("install");
+      console.log(`  ${actionLabel} ${chalk2.cyan(a.connector)}`);
+      console.log(chalk2.dim(`    source: ${a.sourcePath}`));
+      console.log(chalk2.dim(`    dest:   ${a.destPath}`));
+      if (a.files && a.files.length > 0) {
+        console.log(chalk2.dim(`    files (${a.files.length}):`));
+        for (const f of a.files) {
+          console.log(chalk2.dim(`      ${f}`));
+        }
+      }
+      if (a.importLine) {
+        console.log(`    ${chalk2.dim("index.ts:")} ${a.importLine}`);
+      }
+      console.log();
+    }
+    const installCount = actions.filter((a) => a.action === "install").length;
+    const overwriteCount = actions.filter((a) => a.action === "overwrite").length;
+    const skipCount = actions.filter((a) => a.action === "skip").length;
+    const errorCount = actions.filter((a) => a.action === "error").length;
+    const parts = [];
+    if (installCount)
+      parts.push(chalk2.green(`${installCount} to install`));
+    if (overwriteCount)
+      parts.push(chalk2.yellow(`${overwriteCount} to overwrite`));
+    if (skipCount)
+      parts.push(chalk2.yellow(`${skipCount} skipped`));
+    if (errorCount)
+      parts.push(chalk2.red(`${errorCount} failed`));
+    console.log(`  ${chalk2.bold("Summary:")} ${parts.join(", ")}`);
+    console.log(chalk2.dim(`
+  Run without --dry-run to apply.
+`));
+    process.exit(errorCount > 0 ? 1 : 0);
+    return;
+  }
+  const results = connectors.map((name) => installConnector(name, { overwrite: options.overwrite }));
   if (options.json) {
     console.log(JSON.stringify(results, null, 2));
     process.exit(results.every((r) => r.success) ? 0 : 1);
     return;
   }
+  console.log(chalk2.bold(`
+Installing connectors...
+`));
+  const succeeded = [];
   for (const result of results) {
     if (result.success) {
-      console.log(chalk2.green(`\u2713 ${result.connector}`) + chalk2.dim(` \u2014 available at ${result.path}`));
+      console.log(chalk2.green(`\u2713 ${result.connector}`));
+      succeeded.push(result.connector);
     } else {
       console.log(chalk2.red(`\u2717 ${result.connector}: ${result.error}`));
     }
   }
+  if (succeeded.length > 0) {
+    console.log(chalk2.bold(`
+Next steps:`));
+    const importNames = succeeded.join(", ");
+    console.log(chalk2.dim(`  1. Import:  `) + `import { ${importNames} } from './.connectors'`);
+    console.log(chalk2.dim(`  2. Set key: `) + `connectors docs ${succeeded[0]}` + chalk2.dim(` (see env vars)`));
+    console.log(chalk2.dim(`  3. Explore: `) + `connectors serve` + chalk2.dim(` (dashboard for auth management)`));
+  }
   process.exit(results.every((r) => r.success) ? 0 : 1);
 });
 program2.command("list").alias("ls").option("-c, --category <category>", "Filter by category").option("-a, --all", "Show all available connectors", false).option("-i, --installed", "Show only installed connectors", false).option("-b, --brief", "Output only connector names", false).option("--json", "Output as JSON", false).description("List available or installed connectors").action((options) => {
@@ -12542,10 +14112,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) {
@@ -12555,10 +14133,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) => {
@@ -12792,17 +14372,17 @@ Updating ${toUpdate.length} connector(s)...
 });
 program2.command("status").option("--json", "Output as JSON", false).description("Show auth status of all configured connectors (project + global)").action((options) => {
   const installed = getInstalledConnectors();
-  const configDir = join6(homedir3(), ".connectors");
+  const configDir = join9(homedir7(), ".connectors");
   const seen = new Set;
   const allStatuses = [];
   function buildStatusEntry(name, source) {
     const auth = getAuthStatus(name);
     const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
-    const currentProfileFile = join6(configDir, connectorName, "current_profile");
+    const currentProfileFile = join9(configDir, connectorName, "current_profile");
     let profile = "default";
-    if (existsSync6(currentProfileFile)) {
+    if (existsSync8(currentProfileFile)) {
       try {
-        profile = readFileSync5(currentProfileFile, "utf-8").trim() || "default";
+        profile = readFileSync6(currentProfileFile, "utf-8").trim() || "default";
       } catch {}
     }
     let expiryLabel = null;
@@ -12838,13 +14418,13 @@ program2.command("status").option("--json", "Output as JSON", false).description
     seen.add(name);
     allStatuses.push(buildStatusEntry(name, "project"));
   }
-  if (existsSync6(configDir)) {
+  if (existsSync8(configDir)) {
     try {
       const globalDirs = readdirSync4(configDir).filter((f) => {
         if (!f.startsWith("connect-"))
           return false;
         try {
-          return statSync3(join6(configDir, f)).isDirectory();
+          return statSync4(join9(configDir, f)).isDirectory();
         } catch {
           return false;
         }
@@ -13118,7 +14698,7 @@ Open this URL to authenticate:
     return;
   }
   if (options.key) {
-    saveApiKey(connector, options.key, options.field || undefined);
+    await saveApiKey(connector, options.key, options.field || undefined);
     const statusAfter2 = getAuthStatus(connector);
     if (options.json) {
       console.log(JSON.stringify({
@@ -13192,7 +14772,7 @@ Open this URL to authenticate:
     process.exit(1);
     return;
   }
-  saveApiKey(connector, key.trim(), options.field || undefined);
+  await saveApiKey(connector, key.trim(), options.field || undefined);
   const statusAfter = getAuthStatus(connector);
   console.log(chalk2.green(`
 \u2713 API key saved for ${meta.displayName}`));
@@ -13209,15 +14789,15 @@ program2.command("init").option("--json", "Output presets and suggestions as JSO
     { key: "commerce", emoji: "\uD83D\uDCB3", label: "Commerce", connectors: ["stripe", "shopify", "paypal", "revolut", "mercury"], description: "Commerce and finance" },
     { key: "google", emoji: "\uD83D\uDCC1", label: "Google Workspace", connectors: ["gmail", "googledrive", "googlecalendar", "googledocs", "googlesheets"], description: "Google Workspace suite" }
   ];
-  const connectorsHome = join6(homedir3(), ".connectors");
+  const connectorsHome = join9(homedir7(), ".connectors");
   let configuredCount = 0;
   const configuredNames = [];
   try {
-    if (existsSync6(connectorsHome)) {
-      const entries = readdirSync4(connectorsHome).filter((e) => e.startsWith("connect-") && statSync3(join6(connectorsHome, e)).isDirectory());
+    if (existsSync8(connectorsHome)) {
+      const entries = readdirSync4(connectorsHome).filter((e) => e.startsWith("connect-") && statSync4(join9(connectorsHome, e)).isDirectory());
       for (const entry of entries) {
-        const profilesDir = join6(connectorsHome, entry, "profiles");
-        if (existsSync6(profilesDir)) {
+        const profilesDir = join9(connectorsHome, entry, "profiles");
+        if (existsSync8(profilesDir)) {
           configuredCount++;
           configuredNames.push(entry.replace(/^connect-/, ""));
         }
@@ -13315,44 +14895,44 @@ function redactSecrets(obj) {
   return obj;
 }
 program2.command("export").option("-o, --output <file>", "Write to file instead of stdout").option("--include-secrets", "Include secrets in plaintext (dangerous \u2014 use only for backup/restore)").description("Export all connector credentials as JSON backup").action((options) => {
-  const connectDir = join6(homedir3(), ".connectors");
+  const connectDir = join9(homedir7(), ".connectors");
   const result = {};
-  if (existsSync6(connectDir)) {
+  if (existsSync8(connectDir)) {
     for (const entry of readdirSync4(connectDir)) {
-      const entryPath = join6(connectDir, entry);
-      if (!statSync3(entryPath).isDirectory() || !entry.startsWith("connect-"))
+      const entryPath = join9(connectDir, entry);
+      if (!statSync4(entryPath).isDirectory() || !entry.startsWith("connect-"))
         continue;
       const connectorName = entry.replace(/^connect-/, "");
       let credentials = undefined;
-      const credentialsPath = join6(entryPath, "credentials.json");
-      if (existsSync6(credentialsPath)) {
+      const credentialsPath = join9(entryPath, "credentials.json");
+      if (existsSync8(credentialsPath)) {
         try {
-          credentials = JSON.parse(readFileSync5(credentialsPath, "utf-8"));
+          credentials = JSON.parse(readFileSync6(credentialsPath, "utf-8"));
         } catch {}
       }
-      const profilesDir = join6(entryPath, "profiles");
-      if (!existsSync6(profilesDir) && !credentials)
+      const profilesDir = join9(entryPath, "profiles");
+      if (!existsSync8(profilesDir) && !credentials)
         continue;
       const profiles = {};
-      if (existsSync6(profilesDir)) {
+      if (existsSync8(profilesDir)) {
         for (const pEntry of readdirSync4(profilesDir)) {
-          const pPath = join6(profilesDir, pEntry);
-          if (statSync3(pPath).isFile() && pEntry.endsWith(".json")) {
+          const pPath = join9(profilesDir, pEntry);
+          if (statSync4(pPath).isFile() && pEntry.endsWith(".json")) {
             try {
-              profiles[pEntry.replace(/\.json$/, "")] = JSON.parse(readFileSync5(pPath, "utf-8"));
+              profiles[pEntry.replace(/\.json$/, "")] = JSON.parse(readFileSync6(pPath, "utf-8"));
             } catch {}
-          } else if (statSync3(pPath).isDirectory()) {
-            const configPath = join6(pPath, "config.json");
-            const tokensPath = join6(pPath, "tokens.json");
+          } else if (statSync4(pPath).isDirectory()) {
+            const configPath = join9(pPath, "config.json");
+            const tokensPath = join9(pPath, "tokens.json");
             let merged = {};
-            if (existsSync6(configPath)) {
+            if (existsSync8(configPath)) {
               try {
-                merged = { ...merged, ...JSON.parse(readFileSync5(configPath, "utf-8")) };
+                merged = { ...merged, ...JSON.parse(readFileSync6(configPath, "utf-8")) };
               } catch {}
             }
-            if (existsSync6(tokensPath)) {
+            if (existsSync8(tokensPath)) {
               try {
-                merged = { ...merged, ...JSON.parse(readFileSync5(tokensPath, "utf-8")) };
+                merged = { ...merged, ...JSON.parse(readFileSync6(tokensPath, "utf-8")) };
               } catch {}
             }
             if (Object.keys(merged).length > 0)
@@ -13373,7 +14953,7 @@ program2.command("export").option("-o, --output <file>", "Write to file instead
   }
   const exportData = JSON.stringify(exportPayload, null, 2);
   if (options.output) {
-    writeFileSync3(options.output, exportData);
+    writeFileSync5(options.output, exportData);
     console.log(chalk2.green(`\u2713 Exported to ${options.output}`));
   } else {
     console.log(exportData);
@@ -13387,7 +14967,7 @@ program2.command("import").argument("<file>", "JSON backup file to import (use -
       chunks.push(chunk.toString());
     raw = chunks.join("");
   } else {
-    if (!existsSync6(file)) {
+    if (!existsSync8(file)) {
       if (options.json) {
         console.log(JSON.stringify({ error: `File not found: ${file}` }));
       } else {
@@ -13396,7 +14976,7 @@ program2.command("import").argument("<file>", "JSON backup file to import (use -
       process.exit(1);
       return;
     }
-    raw = readFileSync5(file, "utf-8");
+    raw = readFileSync6(file, "utf-8");
   }
   let data;
   try {
@@ -13419,25 +14999,25 @@ program2.command("import").argument("<file>", "JSON backup file to import (use -
     process.exit(1);
     return;
   }
-  const connectDir = join6(homedir3(), ".connectors");
+  const connectDir = join9(homedir7(), ".connectors");
   let imported = 0;
   for (const [connectorName, connData] of Object.entries(data.connectors)) {
     if (!/^[a-z0-9-]+$/.test(connectorName))
       continue;
-    const connectorDir = join6(connectDir, `connect-${connectorName}`);
+    const connectorDir = join9(connectDir, `connect-${connectorName}`);
     if (connData.credentials && typeof connData.credentials === "object") {
-      mkdirSync3(connectorDir, { recursive: true });
-      writeFileSync3(join6(connectorDir, "credentials.json"), JSON.stringify(connData.credentials, null, 2));
+      mkdirSync7(connectorDir, { recursive: true });
+      writeFileSync5(join9(connectorDir, "credentials.json"), JSON.stringify(connData.credentials, null, 2));
       imported++;
     }
     if (!connData.profiles || typeof connData.profiles !== "object")
       continue;
-    const profilesDir = join6(connectorDir, "profiles");
+    const profilesDir = join9(connectorDir, "profiles");
     for (const [profileName, config] of Object.entries(connData.profiles)) {
       if (!config || typeof config !== "object")
         continue;
-      mkdirSync3(profilesDir, { recursive: true });
-      writeFileSync3(join6(profilesDir, `${profileName}.json`), JSON.stringify(config, null, 2));
+      mkdirSync7(profilesDir, { recursive: true });
+      writeFileSync5(join9(profilesDir, `${profileName}.json`), JSON.stringify(config, null, 2));
       imported++;
     }
   }
@@ -13448,9 +15028,9 @@ program2.command("import").argument("<file>", "JSON backup file to import (use -
   }
 });
 program2.command("auth-import").option("--json", "Output as JSON", false).option("-d, --dry-run", "Preview what would be imported without copying", false).option("--force", "Overwrite existing files in ~/.connectors/", false).description("Migrate auth tokens from ~/.connect/ to ~/.connectors/").action((options) => {
-  const oldBase = join6(homedir3(), ".connect");
-  const newBase = join6(homedir3(), ".connectors");
-  if (!existsSync6(oldBase)) {
+  const oldBase = join9(homedir7(), ".connect");
+  const newBase = join9(homedir7(), ".connectors");
+  if (!existsSync8(oldBase)) {
     if (options.json) {
       console.log(JSON.stringify({ imported: [], skipped: [], error: null, message: "No ~/.connect/ directory found" }));
     } else {
@@ -13462,7 +15042,7 @@ program2.command("auth-import").option("--json", "Output as JSON", false).option
     if (!name.startsWith("connect-"))
       return false;
     try {
-      return statSync3(join6(oldBase, name)).isDirectory();
+      return statSync4(join9(oldBase, name)).isDirectory();
     } catch {
       return false;
     }
@@ -13478,8 +15058,8 @@ program2.command("auth-import").option("--json", "Output as JSON", false).option
   const imported = [];
   const skipped = [];
   for (const dirName of entries) {
-    const oldDir = join6(oldBase, dirName);
-    const newDir = join6(newBase, dirName);
+    const oldDir = join9(oldBase, dirName);
+    const newDir = join9(newBase, dirName);
     const connectorName = dirName.replace(/^connect-/, "");
     const allFiles = listFilesRecursive(oldDir);
     const authFiles = allFiles.filter((f) => {
@@ -13490,17 +15070,17 @@ program2.command("auth-import").option("--json", "Output as JSON", false).option
     const copiedFiles = [];
     const skippedFiles = [];
     for (const relFile of authFiles) {
-      const srcPath = join6(oldDir, relFile);
-      const destPath = join6(newDir, relFile);
-      if (existsSync6(destPath) && !options.force) {
+      const srcPath = join9(oldDir, relFile);
+      const destPath = join9(newDir, relFile);
+      if (existsSync8(destPath) && !options.force) {
         skippedFiles.push(relFile);
         continue;
       }
       if (!options.dryRun) {
-        const parentDir = join6(destPath, "..");
-        mkdirSync3(parentDir, { recursive: true });
-        const content = readFileSync5(srcPath);
-        writeFileSync3(destPath, content);
+        const parentDir = join9(destPath, "..");
+        mkdirSync7(parentDir, { recursive: true });
+        const content = readFileSync6(srcPath);
+        writeFileSync5(destPath, content);
       }
       copiedFiles.push(relFile);
     }
@@ -13745,7 +15325,7 @@ program2.command("env").option("-o, --output <file>", "Write to file instead of
 `) + `
 `;
   if (options.output) {
-    writeFileSync3(options.output, output);
+    writeFileSync5(options.output, output);
     console.log(chalk2.green(`\u2713 Written to ${options.output} (${vars.length} variables)`));
   } else {
     console.log(output);
@@ -13773,7 +15353,7 @@ Available presets:
 `));
 });
 program2.command("whoami").option("--json", "Output as JSON", false).description("Show current setup: config dir, installed connectors, auth status").action((options) => {
-  const configDir = join6(homedir3(), ".connectors");
+  const configDir = join9(homedir7(), ".connectors");
   const installed = getInstalledConnectors();
   const version = "0.3.1";
   let configured = 0;
@@ -13787,23 +15367,23 @@ program2.command("whoami").option("--json", "Output as JSON", false).description
       configured++;
     else
       unconfigured++;
-    const connectorConfigDir = join6(configDir, name.startsWith("connect-") ? name : `connect-${name}`);
-    const currentProfileFile = join6(connectorConfigDir, "current_profile");
+    const connectorConfigDir = join9(configDir, name.startsWith("connect-") ? name : `connect-${name}`);
+    const currentProfileFile = join9(connectorConfigDir, "current_profile");
     let profile = "default";
-    if (existsSync6(currentProfileFile)) {
+    if (existsSync8(currentProfileFile)) {
       try {
-        profile = readFileSync5(currentProfileFile, "utf-8").trim() || "default";
+        profile = readFileSync6(currentProfileFile, "utf-8").trim() || "default";
       } catch {}
     }
     connectorDetails.push({ name, configured: auth.configured, authType: auth.type, profile, source: "project" });
   }
-  if (existsSync6(configDir)) {
+  if (existsSync8(configDir)) {
     try {
       const globalDirs = readdirSync4(configDir).filter((f) => {
         if (!f.startsWith("connect-"))
           return false;
         try {
-          return statSync3(join6(configDir, f)).isDirectory();
+          return statSync4(join9(configDir, f)).isDirectory();
         } catch {
           return false;
         }
@@ -13817,11 +15397,11 @@ program2.command("whoami").option("--json", "Output as JSON", false).description
           continue;
         seen.add(name);
         configured++;
-        const currentProfileFile = join6(configDir, dir, "current_profile");
+        const currentProfileFile = join9(configDir, dir, "current_profile");
         let profile = "default";
-        if (existsSync6(currentProfileFile)) {
+        if (existsSync8(currentProfileFile)) {
           try {
-            profile = readFileSync5(currentProfileFile, "utf-8").trim() || "default";
+            profile = readFileSync6(currentProfileFile, "utf-8").trim() || "default";
           } catch {}
         }
         connectorDetails.push({ name, configured: true, authType: auth.type, profile, source: "global" });
@@ -13832,7 +15412,7 @@ program2.command("whoami").option("--json", "Output as JSON", false).description
     console.log(JSON.stringify({
       version,
       configDir,
-      configDirExists: existsSync6(configDir),
+      configDirExists: existsSync8(configDir),
       installed: installed.length,
       configured,
       unconfigured,
@@ -13844,7 +15424,7 @@ program2.command("whoami").option("--json", "Output as JSON", false).description
 Connectors Setup
 `));
   console.log(`  Version:      ${chalk2.cyan(version)}`);
-  console.log(`  Config:       ${configDir}${existsSync6(configDir) ? "" : chalk2.dim(" (not created yet)")}`);
+  console.log(`  Config:       ${configDir}${existsSync8(configDir) ? "" : chalk2.dim(" (not created yet)")}`);
   console.log(`  Installed:    ${installed.length} connector${installed.length !== 1 ? "s" : ""}`);
   console.log(`  Configured:   ${chalk2.green(String(configured))} ready, ${unconfigured > 0 ? chalk2.red(String(unconfigured)) : chalk2.dim("0")} need auth`);
   const projectConnectors = connectorDetails.filter((c) => c.source === "project");
@@ -13934,18 +15514,18 @@ Testing connector credentials...
       }
     }
     if (!apiKey) {
-      const connectorConfigDir = join6(homedir3(), ".connectors", name.startsWith("connect-") ? name : `connect-${name}`);
+      const connectorConfigDir = join9(homedir7(), ".connectors", name.startsWith("connect-") ? name : `connect-${name}`);
       let currentProfile = "default";
-      const currentProfileFile = join6(connectorConfigDir, "current_profile");
-      if (existsSync6(currentProfileFile)) {
+      const currentProfileFile = join9(connectorConfigDir, "current_profile");
+      if (existsSync8(currentProfileFile)) {
         try {
-          currentProfile = readFileSync5(currentProfileFile, "utf-8").trim() || "default";
+          currentProfile = readFileSync6(currentProfileFile, "utf-8").trim() || "default";
         } catch {}
       }
-      const tokensFile = join6(connectorConfigDir, "profiles", currentProfile, "tokens.json");
-      if (existsSync6(tokensFile)) {
+      const tokensFile = join9(connectorConfigDir, "profiles", currentProfile, "tokens.json");
+      if (existsSync8(tokensFile)) {
         try {
-          const tokens = JSON.parse(readFileSync5(tokensFile, "utf-8"));
+          const tokens = JSON.parse(readFileSync6(tokensFile, "utf-8"));
           const isExpired = tokens.expiresAt && Date.now() >= tokens.expiresAt - 60000;
           if (isExpired && tokens.refreshToken) {
             try {
@@ -13963,19 +15543,19 @@ Testing connector credentials...
         } catch {}
       }
       if (!apiKey) {
-        const profileFile = join6(connectorConfigDir, "profiles", `${currentProfile}.json`);
-        if (existsSync6(profileFile)) {
+        const profileFile = join9(connectorConfigDir, "profiles", `${currentProfile}.json`);
+        if (existsSync8(profileFile)) {
           try {
-            const config = JSON.parse(readFileSync5(profileFile, "utf-8"));
+            const config = JSON.parse(readFileSync6(profileFile, "utf-8"));
             apiKey = Object.values(config).find((v) => typeof v === "string" && v.length > 0);
           } catch {}
         }
       }
       if (!apiKey) {
-        const profileDirConfig = join6(connectorConfigDir, "profiles", currentProfile, "config.json");
-        if (existsSync6(profileDirConfig)) {
+        const profileDirConfig = join9(connectorConfigDir, "profiles", currentProfile, "config.json");
+        if (existsSync8(profileDirConfig)) {
           try {
-            const config = JSON.parse(readFileSync5(profileDirConfig, "utf-8"));
+            const config = JSON.parse(readFileSync6(profileDirConfig, "utf-8"));
             apiKey = Object.values(config).find((v) => typeof v === "string" && v.length > 0);
           } catch {}
         }
@@ -14112,7 +15692,7 @@ program2.command("run").description("Execute an API operation on a connector").a
     console.error(chalk2.yellow(`No command specified. Run ${chalk2.white(`connectors ops ${name}`)} to see available operations.`));
     process.exit(1);
   }
-  const result = await runConnectorCommand(name, args, parseInt(options.timeout));
+  const result = await runConnectorCommand2(name, args, parseInt(options.timeout));
   if (result.stdout) {
     console.log(result.stdout);
   }
@@ -14142,7 +15722,7 @@ Setting up ${meta.displayName}...
   const alreadyInstalled = installed.includes(meta.name);
   let installResult;
   if (alreadyInstalled && !options.overwrite) {
-    installResult = { success: true, path: join6(process.cwd(), ".connectors", `connect-${meta.name}`) };
+    installResult = { success: true, path: join9(process.cwd(), ".connectors", `connect-${meta.name}`) };
     if (!options.json) {
       console.log(`  ${chalk2.green("\u2713")} Already installed`);
     }
@@ -14167,7 +15747,7 @@ Setting up ${meta.displayName}...
   let authConfigured = false;
   if (authType === "oauth") {
     if (options.key) {
-      saveApiKey(name, options.key, options.field || undefined);
+      await saveApiKey(name, options.key, options.field || undefined);
       authConfigured = true;
       if (!options.json) {
         console.log(`  ${chalk2.green("\u2713")} Token saved`);
@@ -14225,7 +15805,7 @@ Setting up ${meta.displayName}...
     }
   } else {
     if (options.key) {
-      saveApiKey(name, options.key, options.field || undefined);
+      await saveApiKey(name, options.key, options.field || undefined);
       authConfigured = true;
       if (!options.json) {
         console.log(`  ${chalk2.green("\u2713")} ${authType === "bearer" ? "Bearer token" : "API key"} saved`);
@@ -14268,4 +15848,299 @@ 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();
+  const args = options.args ? options.args.split(" ") : [];
+  const job = createJob({ name: options.name, connector: options.connector, command: options.command, args, cron: options.cron, strip: !!options.strip }, db);
+  if (options.json) {
+    console.log(JSON.stringify(job));
+    return;
+  }
+  console.log(chalk2.green("\u2713") + ` Job created: ${job.name} (${job.cron})`);
+});
+jobsCmd.command("list").description("List all jobs").option("--json", "Output as JSON").action((options) => {
+  const jobs = listJobs(getDatabase());
+  if (options.json) {
+    console.log(JSON.stringify(jobs));
+    return;
+  }
+  if (jobs.length === 0) {
+    console.log(chalk2.dim("No jobs configured."));
+    return;
+  }
+  for (const j of jobs) {
+    const status = j.enabled ? chalk2.green("enabled") : chalk2.dim("disabled");
+    const strip = j.strip ? chalk2.cyan(" [strip]") : "";
+    console.log(`  ${j.name.padEnd(20)} ${j.connector}.${j.command.padEnd(16)} ${j.cron.padEnd(15)} ${status}${strip}`);
+  }
+});
+jobsCmd.command("run").description("Manually trigger a job").argument("<name>", "Job name").option("--json", "Output as JSON").action(async (name, options) => {
+  const db = getDatabase();
+  const job = getJobByName(name, db);
+  if (!job) {
+    console.error(chalk2.red(`Job "${name}" not found`));
+    process.exit(1);
+  }
+  if (!options.json)
+    console.log(chalk2.dim(`Running ${job.connector} ${job.command}...`));
+  const result = await triggerJob(job, db);
+  if (options.json) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  const icon = result.exit_code === 0 ? chalk2.green("\u2713") : chalk2.red("\u2717");
+  console.log(`${icon} Run ${result.run_id} \u2014 exit ${result.exit_code}`);
+  if (result.output)
+    console.log(result.output.slice(0, 2000));
+});
+jobsCmd.command("logs").description("Show recent runs for a job").argument("<name>", "Job name").option("--limit <n>", "Max results", "10").option("--json", "Output as JSON").action((name, options) => {
+  const db = getDatabase();
+  const job = getJobByName(name, db);
+  if (!job) {
+    console.error(chalk2.red(`Job "${name}" not found`));
+    process.exit(1);
+  }
+  const runs = listJobRuns(job.id, parseInt(options.limit), db);
+  if (options.json) {
+    console.log(JSON.stringify(runs));
+    return;
+  }
+  if (runs.length === 0) {
+    console.log(chalk2.dim("No runs yet."));
+    return;
+  }
+  for (const r of runs) {
+    const icon = r.exit_code === 0 ? chalk2.green("\u2713") : chalk2.red("\u2717");
+    console.log(`  ${icon} ${r.started_at.slice(0, 19)} \u2014 exit ${r.exit_code ?? "?"}`);
+  }
+});
+jobsCmd.command("enable").description("Enable a job").argument("<name>").action((name) => {
+  const db = getDatabase();
+  const job = getJobByName(name, db);
+  if (!job) {
+    console.error(chalk2.red(`Job "${name}" not found`));
+    process.exit(1);
+  }
+  updateJob(job.id, { enabled: true }, db);
+  console.log(chalk2.green("\u2713") + ` Job "${name}" enabled`);
+});
+jobsCmd.command("disable").description("Disable a job").argument("<name>").action((name) => {
+  const db = getDatabase();
+  const job = getJobByName(name, db);
+  if (!job) {
+    console.error(chalk2.red(`Job "${name}" not found`));
+    process.exit(1);
+  }
+  updateJob(job.id, { enabled: false }, db);
+  console.log(chalk2.green("\u2713") + ` Job "${name}" disabled`);
+});
+jobsCmd.command("delete").description("Delete a job").argument("<name>").action((name) => {
+  const db = getDatabase();
+  const job = getJobByName(name, db);
+  if (!job) {
+    console.error(chalk2.red(`Job "${name}" not found`));
+    process.exit(1);
+  }
+  deleteJob(job.id, db);
+  console.log(chalk2.green("\u2713") + ` Job "${name}" deleted`);
+});
+var workflowsCmd = program2.command("workflows").description("Manage connector workflows (sequential pipelines)");
+workflowsCmd.command("add").description("Create a workflow from a JSON steps array").requiredOption("--name <name>", "Workflow name").requiredOption("--steps <json>", `Steps JSON array, e.g. '[{"connector":"stripe","command":"products list"}]'`).option("--json", "Output as JSON").action((options) => {
+  let steps;
+  try {
+    steps = JSON.parse(options.steps);
+  } catch {
+    console.error(chalk2.red("Invalid JSON for --steps"));
+    process.exit(1);
+  }
+  const wf = createWorkflow({ name: options.name, steps }, getDatabase());
+  if (options.json) {
+    console.log(JSON.stringify(wf));
+    return;
+  }
+  console.log(chalk2.green("\u2713") + ` Workflow "${wf.name}" created (${wf.steps.length} steps)`);
+});
+workflowsCmd.command("list").description("List all workflows").option("--json", "Output as JSON").action((options) => {
+  const wfs = listWorkflows(getDatabase());
+  if (options.json) {
+    console.log(JSON.stringify(wfs));
+    return;
+  }
+  if (wfs.length === 0) {
+    console.log(chalk2.dim("No workflows configured."));
+    return;
+  }
+  for (const wf of wfs) {
+    const status = wf.enabled ? chalk2.green("enabled") : chalk2.dim("disabled");
+    console.log(`  ${wf.name.padEnd(20)} ${String(wf.steps.length).padStart(2)} steps  ${status}`);
+  }
+});
+workflowsCmd.command("run").description("Run a workflow").argument("<name>", "Workflow name").option("--json", "Output as JSON").action(async (name, options) => {
+  const wf = getWorkflowByName(name, getDatabase());
+  if (!wf) {
+    console.error(chalk2.red(`Workflow "${name}" not found`));
+    process.exit(1);
+  }
+  if (!options.json)
+    console.log(chalk2.dim(`Running workflow "${wf.name}" (${wf.steps.length} steps)...`));
+  const result = await runWorkflow(wf);
+  if (options.json) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  for (const step of result.steps) {
+    const icon = step.exit_code === 0 ? chalk2.green("\u2713") : chalk2.red("\u2717");
+    console.log(`  ${icon} Step ${step.step}: ${step.connector} ${step.command}`);
+  }
+  console.log(result.success ? chalk2.green(`
+Workflow completed`) : chalk2.red(`
+Workflow failed`));
+});
+workflowsCmd.command("delete").description("Delete a workflow").argument("<name>").action((name) => {
+  const wf = getWorkflowByName(name, getDatabase());
+  if (!wf) {
+    console.error(chalk2.red(`Workflow "${name}" not found`));
+    process.exit(1);
+  }
+  deleteWorkflow(wf.id, getDatabase());
+  console.log(chalk2.green("\u2713") + ` Workflow "${name}" deleted`);
+});
+var llmCmd = program2.command("llm").description("Manage LLM provider for output stripping");
+llmCmd.command("set").description("Configure LLM provider and API key").requiredOption("--provider <provider>", "Provider: cerebras, groq, openai, anthropic").requiredOption("--key <key>", "API key").option("--model <model>", "Model name (defaults to provider default)").option("--json", "Output as JSON").action((options) => {
+  const provider = options.provider;
+  const validProviders = ["cerebras", "groq", "openai", "anthropic"];
+  if (!validProviders.includes(provider)) {
+    console.error(chalk2.red(`Unknown provider "${provider}". Valid: ${validProviders.join(", ")}`));
+    process.exit(1);
+  }
+  const model = options.model || PROVIDER_DEFAULTS[provider].model;
+  const existing = getLlmConfig();
+  saveLlmConfig({ provider, model, api_key: options.key, strip: existing?.strip ?? false });
+  if (options.json) {
+    console.log(JSON.stringify({ provider, model, key: maskKey(options.key), strip: existing?.strip ?? false }));
+  } else {
+    console.log(chalk2.green("\u2713") + ` LLM configured: ${provider} / ${model}`);
+    console.log(`  Key: ${maskKey(options.key)}`);
+    console.log(`  Strip: ${existing?.strip ? chalk2.green("enabled") : chalk2.dim("disabled")} (run 'connectors llm strip enable' to turn on)`);
+  }
+});
+llmCmd.command("status").description("Show current LLM configuration").option("--json", "Output as JSON").action((options) => {
+  const config = getLlmConfig();
+  if (!config) {
+    if (options.json)
+      console.log(JSON.stringify({ configured: false }));
+    else
+      console.log(chalk2.dim("No LLM configured. Run: connectors llm set --provider <provider> --key <key>"));
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ configured: true, provider: config.provider, model: config.model, key: maskKey(config.api_key), strip: config.strip }));
+  } else {
+    console.log(chalk2.bold("LLM Configuration"));
+    console.log(`  Provider : ${config.provider}`);
+    console.log(`  Model    : ${config.model}`);
+    console.log(`  Key      : ${maskKey(config.api_key)}`);
+    console.log(`  Strip    : ${config.strip ? chalk2.green("enabled") : chalk2.red("disabled")}`);
+  }
+});
+llmCmd.command("strip").description("Enable or disable global output stripping").argument("<action>", "enable or disable").action((action) => {
+  if (action !== "enable" && action !== "disable") {
+    console.error(chalk2.red('Action must be "enable" or "disable"'));
+    process.exit(1);
+  }
+  try {
+    setLlmStrip(action === "enable");
+    console.log(chalk2.green("\u2713") + ` Output stripping ${action}d`);
+  } catch (e) {
+    console.error(chalk2.red(String(e instanceof Error ? e.message : e)));
+    process.exit(1);
+  }
+});
+llmCmd.command("test").description("Test current LLM configuration with a sample prompt").option("--json", "Output as JSON").action(async (options) => {
+  const config = getLlmConfig();
+  if (!config) {
+    console.error(chalk2.red("No LLM configured. Run: connectors llm set --provider <provider> --key <key>"));
+    process.exit(1);
+  }
+  if (!options.json)
+    console.log(chalk2.dim(`Testing ${config.provider} / ${config.model}...`));
+  try {
+    const client = new LLMClient(config);
+    const result = await client.complete('You are a helpful assistant. Respond with exactly: {"status":"ok"}', "ping");
+    if (options.json) {
+      console.log(JSON.stringify({ success: true, provider: result.provider, model: result.model, latency_ms: result.latency_ms, response: result.content }));
+    } else {
+      console.log(chalk2.green("\u2713") + ` Response received in ${result.latency_ms}ms`);
+      console.log(`  ${result.content.trim()}`);
+    }
+  } catch (e) {
+    if (options.json)
+      console.log(JSON.stringify({ success: false, error: String(e instanceof Error ? e.message : e) }));
+    else
+      console.error(chalk2.red("\u2717 " + String(e instanceof Error ? e.message : e)));
+    process.exit(1);
+  }
+});
+llmCmd.command("providers").description("List supported LLM providers").option("--json", "Output as JSON").action((options) => {
+  const providers = [
+    { name: "cerebras", baseUrl: "https://api.cerebras.ai/v1", defaultModel: PROVIDER_DEFAULTS.cerebras.model, compatible: "OpenAI" },
+    { name: "groq", baseUrl: "https://api.groq.com/openai/v1", defaultModel: PROVIDER_DEFAULTS.groq.model, compatible: "OpenAI" },
+    { name: "openai", baseUrl: "https://api.openai.com/v1", defaultModel: PROVIDER_DEFAULTS.openai.model, compatible: "OpenAI" },
+    { name: "anthropic", baseUrl: "https://api.anthropic.com/v1", defaultModel: PROVIDER_DEFAULTS.anthropic.model, compatible: "Anthropic" }
+  ];
+  if (options.json) {
+    console.log(JSON.stringify(providers));
+    return;
+  }
+  console.log(chalk2.bold("Supported LLM Providers"));
+  for (const p of providers) {
+    console.log(`  ${chalk2.cyan(p.name.padEnd(12))} ${p.defaultModel.padEnd(30)} ${chalk2.dim(p.baseUrl)}`);
+  }
+});
 program2.parse();