@hasna/connectors 0.2.4 → 0.2.6

package/README.md

@@ -34,6 +34,8 @@ npx @hasna/connectors
 
 ```bash
 connectors install figma stripe github   # Install connectors
+connectors install --preset ai           # Install a preset bundle
+connectors install --category "AI & ML"  # Install entire category
 connectors install figma --overwrite     # Overwrite existing
 connectors remove figma                  # Remove a connector
 ```
@@ -49,6 +51,10 @@ connectors info stripe                   # Connector details
 connectors docs gmail                    # Auth, env vars, CLI docs
 connectors status                        # Auth status of installed connectors
 connectors doctor                        # Health check and troubleshooting
+connectors test                          # Verify API keys with real requests
+connectors whoami                        # Show setup summary
+connectors env                           # Generate .env.example
+connectors presets                       # List preset bundles
 ```
 
 ### Dashboard

package/bin/index.js

@@ -6496,14 +6496,94 @@ function App({ initialConnectors, overwrite = false }) {
 init_registry();
 init_installer();
 init_auth();
-import { readdirSync as readdirSync4, statSync as statSync3 } from "fs";
+import { readdirSync as readdirSync4, existsSync as existsSync5, statSync as statSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { homedir as homedir3 } from "os";
 import { join as join5, relative } from "path";
+
+// src/lib/test-endpoints.ts
+var TEST_ENDPOINTS = {
+  anthropic: {
+    url: "https://api.anthropic.com/v1/models",
+    headers: (key) => ({ "x-api-key": key, "anthropic-version": "2023-06-01" })
+  },
+  openai: {
+    url: "https://api.openai.com/v1/models",
+    headers: (key) => ({ Authorization: `Bearer ${key}` })
+  },
+  xai: {
+    url: "https://api.x.ai/v1/models",
+    headers: (key) => ({ Authorization: `Bearer ${key}` })
+  },
+  mistral: {
+    url: "https://api.mistral.ai/v1/models",
+    headers: (key) => ({ Authorization: `Bearer ${key}` })
+  },
+  github: {
+    url: "https://api.github.com/user",
+    headers: (key) => ({ Authorization: `Bearer ${key}`, "User-Agent": "connectors-cli" })
+  },
+  stripe: {
+    url: "https://api.stripe.com/v1/balance",
+    headers: (key) => ({ Authorization: `Bearer ${key}` })
+  },
+  figma: {
+    url: "https://api.figma.com/v1/me",
+    headers: (key) => ({ "X-Figma-Token": key })
+  },
+  discord: {
+    url: "https://discord.com/api/v10/users/@me",
+    headers: (key) => ({ Authorization: `Bot ${key}` })
+  },
+  resend: {
+    url: "https://api.resend.com/domains",
+    headers: (key) => ({ Authorization: `Bearer ${key}` })
+  },
+  notion: {
+    url: "https://api.notion.com/v1/users/me",
+    headers: (key) => ({ Authorization: `Bearer ${key}`, "Notion-Version": "2022-06-28" })
+  },
+  exa: {
+    url: "https://api.exa.ai/search",
+    method: "POST",
+    headers: (key) => ({ "x-api-key": key, "Content-Type": "application/json" })
+  },
+  sentry: {
+    url: "https://sentry.io/api/0/",
+    headers: (key) => ({ Authorization: `Bearer ${key}` })
+  },
+  huggingface: {
+    url: "https://huggingface.co/api/whoami-v2",
+    headers: (key) => ({ Authorization: `Bearer ${key}` })
+  },
+  elevenlabs: {
+    url: "https://api.elevenlabs.io/v1/user",
+    headers: (key) => ({ "xi-api-key": key })
+  },
+  cloudflare: {
+    url: "https://api.cloudflare.com/client/v4/user/tokens/verify",
+    headers: (key) => ({ Authorization: `Bearer ${key}` })
+  },
+  mixpanel: {
+    url: "https://mixpanel.com/api/app/me",
+    headers: (key) => ({ Authorization: `Bearer ${key}` })
+  }
+};
+
+// src/cli/index.tsx
 import { createInterface } from "readline";
 import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
 loadConnectorVersions();
 var isTTY = process.stdout.isTTY ?? false;
+var PRESETS = {
+  fullstack: { description: "Full-stack web app essentials", connectors: ["stripe", "github", "resend", "anthropic", "figma"] },
+  ai: { description: "AI and ML models", connectors: ["anthropic", "openai", "xai", "mistral", "googlegemini", "elevenlabs"] },
+  google: { description: "Google Workspace suite", connectors: ["gmail", "googledrive", "googledocs", "googlesheets", "googlecalendar", "googletasks", "googlecontacts"] },
+  social: { description: "Social media platforms", connectors: ["x", "reddit", "youtube", "tiktok", "meta", "discord", "substack"] },
+  devtools: { description: "Developer tooling", connectors: ["github", "docker", "sentry", "cloudflare", "e2b", "firecrawl"] },
+  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("0.2.4");
+program2.name("connectors").description("Install API connectors for your project").version("0.2.6");
 program2.command("interactive", { isDefault: true }).alias("i").description("Interactive connector browser").action(() => {
   if (!isTTY) {
     console.log(`Non-interactive environment detected. Use a subcommand:
@@ -6533,7 +6613,36 @@ function listFilesRecursive(dir, base = dir) {
   }
   return files;
 }
-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("--json", "Output results as JSON", false).description("Install one or more connectors").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) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: `Unknown category: ${options.category}. Available: ${CATEGORIES.join(", ")}` }));
+      } else {
+        console.log(chalk2.red(`Unknown category: ${options.category}`));
+        console.log(chalk2.dim(`Available: ${CATEGORIES.join(", ")}`));
+      }
+      process.exit(1);
+      return;
+    }
+    const categoryConnectors = getConnectorsByCategory(category).map((c) => c.name);
+    connectors.push(...categoryConnectors);
+  }
+  if (options.preset) {
+    const preset = PRESETS[options.preset.toLowerCase()];
+    if (!preset) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: `Unknown preset: ${options.preset}. Available: ${Object.keys(PRESETS).join(", ")}` }));
+      } else {
+        console.log(chalk2.red(`Unknown preset: ${options.preset}`));
+        console.log(chalk2.dim(`Available: ${Object.keys(PRESETS).join(", ")}`));
+      }
+      process.exit(1);
+      return;
+    }
+    connectors.push(...preset.connectors);
+  }
   if (connectors.length === 0) {
     if (!isTTY) {
       console.error("Error: specify connectors to install. Example: connectors install figma stripe");
@@ -6665,7 +6774,41 @@ Next steps:`));
   }
   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("--json", "Output as JSON", false).description("List available or installed connectors").action((options) => {
+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) => {
+  if (options.brief) {
+    if (options.installed) {
+      const installed = getInstalledConnectors();
+      if (options.json) {
+        console.log(JSON.stringify(installed));
+      } else {
+        for (const name of installed)
+          console.log(name);
+      }
+    } else if (options.category) {
+      const category = CATEGORIES.find((c) => c.toLowerCase() === options.category.toLowerCase());
+      if (!category) {
+        console.error(`Unknown category: ${options.category}`);
+        process.exit(1);
+        return;
+      }
+      const names = getConnectorsByCategory(category).map((c) => c.name);
+      if (options.json) {
+        console.log(JSON.stringify(names));
+      } else {
+        for (const n of names)
+          console.log(n);
+      }
+    } else {
+      const names = CONNECTORS.map((c) => c.name);
+      if (options.json) {
+        console.log(JSON.stringify(names));
+      } else {
+        for (const n of names)
+          console.log(n);
+      }
+    }
+    return;
+  }
   if (options.installed) {
     const installed = getInstalledConnectors();
     if (installed.length === 0) {
@@ -7284,13 +7427,10 @@ Open this URL to authenticate:
         connector,
         authType,
         configured: statusAfter2.configured,
-        field: options.field || null
+        field: options.field || "apiKey"
       }));
     } else {
-      console.log(chalk2.green(`\u2713 API key saved for ${meta.displayName}`));
-      if (options.field) {
-        console.log(chalk2.dim(`  Field: ${options.field}`));
-      }
+      console.log(chalk2.green(`\u2713 Saved ${options.field || "apiKey"} for ${meta.displayName}`));
     }
     process.exit(0);
     return;
@@ -7503,4 +7643,503 @@ Next steps:
   console.log();
   process.exit(results.every((r) => r.success) ? 0 : 1);
 });
+program2.command("export").option("-o, --output <file>", "Write to file instead of stdout").description("Export all connector credentials as JSON backup").action((options) => {
+  const connectDir = join5(homedir3(), ".connectors");
+  const result = {};
+  if (existsSync5(connectDir)) {
+    for (const entry of readdirSync4(connectDir)) {
+      const entryPath = join5(connectDir, entry);
+      if (!statSync3(entryPath).isDirectory() || !entry.startsWith("connect-"))
+        continue;
+      const connectorName = entry.replace(/^connect-/, "");
+      const profilesDir = join5(entryPath, "profiles");
+      if (!existsSync5(profilesDir))
+        continue;
+      const profiles = {};
+      for (const pEntry of readdirSync4(profilesDir)) {
+        const pPath = join5(profilesDir, pEntry);
+        if (statSync3(pPath).isFile() && pEntry.endsWith(".json")) {
+          try {
+            profiles[pEntry.replace(/\.json$/, "")] = JSON.parse(readFileSync5(pPath, "utf-8"));
+          } catch {}
+        } else if (statSync3(pPath).isDirectory()) {
+          const configPath = join5(pPath, "config.json");
+          if (existsSync5(configPath)) {
+            try {
+              profiles[pEntry] = JSON.parse(readFileSync5(configPath, "utf-8"));
+            } catch {}
+          }
+        }
+      }
+      if (Object.keys(profiles).length > 0)
+        result[connectorName] = { profiles };
+    }
+  }
+  const exportData = JSON.stringify({ connectors: result, exportedAt: new Date().toISOString() }, null, 2);
+  if (options.output) {
+    writeFileSync4(options.output, exportData);
+    console.log(chalk2.green(`\u2713 Exported to ${options.output}`));
+  } else {
+    console.log(exportData);
+  }
+});
+program2.command("import").argument("<file>", "JSON backup file to import (use - for stdin)").option("--json", "Output as JSON", false).description("Import connector credentials from a JSON backup").action(async (file, options) => {
+  let raw;
+  if (file === "-") {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+      chunks.push(chunk.toString());
+    raw = chunks.join("");
+  } else {
+    if (!existsSync5(file)) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: `File not found: ${file}` }));
+      } else {
+        console.log(chalk2.red(`File not found: ${file}`));
+      }
+      process.exit(1);
+      return;
+    }
+    raw = readFileSync5(file, "utf-8");
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Invalid JSON" }));
+    } else {
+      console.log(chalk2.red("Invalid JSON in import file"));
+    }
+    process.exit(1);
+    return;
+  }
+  if (!data.connectors || typeof data.connectors !== "object") {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Invalid format: missing 'connectors' object" }));
+    } else {
+      console.log(chalk2.red("Invalid format: missing 'connectors' object"));
+    }
+    process.exit(1);
+    return;
+  }
+  const connectDir = join5(homedir3(), ".connectors");
+  let imported = 0;
+  for (const [connectorName, connData] of Object.entries(data.connectors)) {
+    if (!/^[a-z0-9-]+$/.test(connectorName))
+      continue;
+    if (!connData.profiles || typeof connData.profiles !== "object")
+      continue;
+    const profilesDir = join5(connectDir, `connect-${connectorName}`, "profiles");
+    for (const [profileName, config] of Object.entries(connData.profiles)) {
+      if (!config || typeof config !== "object")
+        continue;
+      mkdirSync4(profilesDir, { recursive: true });
+      writeFileSync4(join5(profilesDir, `${profileName}.json`), JSON.stringify(config, null, 2));
+      imported++;
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ success: true, imported }));
+  } else {
+    console.log(chalk2.green(`\u2713 Imported ${imported} profile(s)`));
+  }
+});
+program2.command("upgrade").alias("self-update").option("--check", "Only check for updates, don't install", false).option("--json", "Output as JSON", false).description("Check for updates and upgrade to the latest version").action(async (options) => {
+  const currentVersion = "0.2.6";
+  try {
+    const res = await fetch("https://registry.npmjs.org/@hasna/connectors/latest");
+    if (!res.ok)
+      throw new Error(`npm registry returned ${res.status}`);
+    const data = await res.json();
+    const latestVersion = data.version;
+    const isUpToDate = currentVersion === latestVersion;
+    if (options.json) {
+      console.log(JSON.stringify({ current: currentVersion, latest: latestVersion, upToDate: isUpToDate }));
+      if (options.check) {
+        process.exit(isUpToDate ? 0 : 1);
+        return;
+      }
+    } else {
+      console.log(`
+  Current: ${chalk2.cyan(currentVersion)}`);
+      console.log(`  Latest:  ${chalk2.cyan(latestVersion)}`);
+      if (isUpToDate) {
+        console.log(chalk2.green(`
+  Already up to date!
+`));
+        process.exit(0);
+        return;
+      }
+      console.log(chalk2.yellow(`
+  Update available: ${currentVersion} \u2192 ${latestVersion}`));
+    }
+    if (options.check) {
+      if (!options.json)
+        console.log(chalk2.dim(`
+  Run 'connectors upgrade' to install.
+`));
+      process.exit(isUpToDate ? 0 : 1);
+      return;
+    }
+    if (!options.json)
+      console.log(chalk2.dim(`
+  Upgrading...`));
+    const { execSync } = await import("child_process");
+    try {
+      execSync(`bun install -g @hasna/connectors@${latestVersion}`, { stdio: options.json ? "pipe" : "inherit" });
+    } catch {
+      try {
+        execSync(`npm install -g @hasna/connectors@${latestVersion}`, { stdio: options.json ? "pipe" : "inherit" });
+      } catch (e) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: "Failed to upgrade. Try manually: bun install -g @hasna/connectors@latest" }));
+        } else {
+          console.log(chalk2.red(`
+  Failed to upgrade. Try manually:`));
+          console.log(chalk2.dim(`  bun install -g @hasna/connectors@latest
+`));
+        }
+        process.exit(1);
+        return;
+      }
+    }
+    if (options.json) {
+      console.log(JSON.stringify({ upgraded: true, from: currentVersion, to: latestVersion }));
+    } else {
+      console.log(chalk2.green(`
+  Upgraded to ${latestVersion}!
+`));
+    }
+  } catch (e) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: e instanceof Error ? e.message : "Failed to check for updates" }));
+    } else {
+      console.log(chalk2.red(`
+  Failed to check for updates: ${e instanceof Error ? e.message : e}
+`));
+    }
+    process.exit(1);
+  }
+});
+program2.command("completions").argument("<shell>", "Shell type: bash, zsh, or fish").description("Output shell completion script").action((shell) => {
+  const commands = ["interactive", "install", "list", "search", "info", "docs", "remove", "categories", "serve", "update", "status", "doctor", "auth", "init", "export", "import", "upgrade", "completions"];
+  const connectorNames = CONNECTORS.map((c) => c.name);
+  const categoryNames = CATEGORIES.map((c) => `"${c}"`);
+  if (shell === "zsh") {
+    console.log(`#compdef connectors
+_connectors() {
+  local -a commands connectors categories
+  commands=(${commands.join(" ")})
+  connectors=(${connectorNames.join(" ")})
+  categories=(${categoryNames.map((c) => c.replace(/"/g, "\\\"")).join(" ")})
+
+  if (( CURRENT == 2 )); then
+    _describe 'command' commands
+  elif (( CURRENT == 3 )); then
+    case "\${words[2]}" in
+      install|add|info|docs|remove|rm|auth)
+        _describe 'connector' connectors ;;
+      search) _message 'search query' ;;
+      list|ls) _arguments '--category[Filter by category]:category:(${CATEGORIES.join(" ").replace(/&/g, "\\&")})' '--installed' '--json' '--brief' ;;
+      *) ;;
+    esac
+  fi
+}
+compdef _connectors connectors`);
+  } else if (shell === "bash") {
+    console.log(`_connectors() {
+  local cur prev commands connectors
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="${commands.join(" ")}"
+  connectors="${connectorNames.join(" ")}"
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+  elif [[ \${COMP_CWORD} -eq 2 ]]; then
+    case "\${prev}" in
+      install|add|info|docs|remove|rm|auth)
+        COMPREPLY=( $(compgen -W "\${connectors}" -- "\${cur}") ) ;;
+    esac
+  fi
+}
+complete -F _connectors connectors`);
+  } else if (shell === "fish") {
+    let script = `# Fish completions for connectors
+`;
+    for (const cmd of commands) {
+      script += `complete -c connectors -n "__fish_use_subcommand" -a "${cmd}"
+`;
+    }
+    script += `# Connector names for install/info/docs/remove/auth
+`;
+    for (const name of connectorNames) {
+      script += `complete -c connectors -n "__fish_seen_subcommand_from install add info docs remove rm auth" -a "${name}"
+`;
+    }
+    console.log(script);
+  } else {
+    console.error(`Unknown shell: ${shell}. Supported: bash, zsh, fish`);
+    process.exit(1);
+  }
+});
+program2.command("env").option("-o, --output <file>", "Write to file instead of stdout").option("--json", "Output as JSON", false).description("Generate .env.example from installed connectors' required env vars").action((options) => {
+  const installed = getInstalledConnectors();
+  if (installed.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ vars: [], connectors: [] }));
+    } else {
+      console.log(chalk2.dim("No connectors installed. Run: connectors install <name>"));
+    }
+    return;
+  }
+  const vars = [];
+  const seen = new Set;
+  for (const name of installed) {
+    const docs = getConnectorDocs(name);
+    if (!docs?.envVars)
+      continue;
+    for (const v of docs.envVars) {
+      if (!seen.has(v.variable)) {
+        seen.add(v.variable);
+        vars.push({ variable: v.variable, description: v.description, connector: name });
+      }
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ vars, connectors: installed }, null, 2));
+    return;
+  }
+  const lines = [
+    "# Environment Variables",
+    `# Generated by connectors env (${installed.length} installed connectors)`,
+    "#"
+  ];
+  let lastConnector = "";
+  for (const v of vars) {
+    if (v.connector !== lastConnector) {
+      lines.push("");
+      lines.push(`# ${v.connector}`);
+      lastConnector = v.connector;
+    }
+    if (v.description)
+      lines.push(`# ${v.description}`);
+    lines.push(`${v.variable}=`);
+  }
+  const output = lines.join(`
+`) + `
+`;
+  if (options.output) {
+    writeFileSync4(options.output, output);
+    console.log(chalk2.green(`\u2713 Written to ${options.output} (${vars.length} variables)`));
+  } else {
+    console.log(output);
+  }
+});
+program2.command("presets").option("--json", "Output as JSON", false).description("List available connector preset bundles").action((options) => {
+  if (options.json) {
+    console.log(JSON.stringify(Object.entries(PRESETS).map(([name, p]) => ({
+      name,
+      description: p.description,
+      connectors: p.connectors,
+      count: p.connectors.length
+    })), null, 2));
+    return;
+  }
+  console.log(chalk2.bold(`
+Available presets:
+`));
+  for (const [name, preset] of Object.entries(PRESETS)) {
+    console.log(`  ${chalk2.cyan(name.padEnd(12))} ${preset.description}`);
+    console.log(chalk2.dim(`  ${"".padEnd(12)} ${preset.connectors.join(", ")}`));
+    console.log();
+  }
+  console.log(chalk2.dim(`  Install with: connectors install --preset <name>
+`));
+});
+program2.command("whoami").option("--json", "Output as JSON", false).description("Show current setup: config dir, installed connectors, auth status").action((options) => {
+  const configDir = join5(homedir3(), ".connectors");
+  const installed = getInstalledConnectors();
+  const version = "0.2.6";
+  let configured = 0;
+  let unconfigured = 0;
+  const connectorDetails = [];
+  for (const name of installed) {
+    const auth = getAuthStatus(name);
+    if (auth.configured)
+      configured++;
+    else
+      unconfigured++;
+    const connectorConfigDir = join5(configDir, name.startsWith("connect-") ? name : `connect-${name}`);
+    const currentProfileFile = join5(connectorConfigDir, "current_profile");
+    let profile = "default";
+    if (existsSync5(currentProfileFile)) {
+      try {
+        profile = readFileSync5(currentProfileFile, "utf-8").trim() || "default";
+      } catch {}
+    }
+    connectorDetails.push({ name, configured: auth.configured, authType: auth.type, profile });
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      version,
+      configDir,
+      configDirExists: existsSync5(configDir),
+      installed: installed.length,
+      configured,
+      unconfigured,
+      connectors: connectorDetails
+    }, null, 2));
+    return;
+  }
+  console.log(chalk2.bold(`
+Connectors Setup
+`));
+  console.log(`  Version:      ${chalk2.cyan(version)}`);
+  console.log(`  Config:       ${configDir}${existsSync5(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`);
+  if (connectorDetails.length > 0) {
+    console.log(chalk2.bold(`
+  Connectors:
+`));
+    const nameWidth = Math.max(10, ...connectorDetails.map((c) => c.name.length)) + 2;
+    for (const c of connectorDetails) {
+      const status = c.configured ? chalk2.green("\u2713") : chalk2.red("\u2717");
+      const profileLabel = c.profile !== "default" ? chalk2.dim(` [${c.profile}]`) : "";
+      console.log(`    ${status} ${chalk2.cyan(c.name.padEnd(nameWidth))}${c.authType.padEnd(8)}${profileLabel}`);
+    }
+  }
+  console.log();
+});
+program2.command("test").argument("[connector]", "Connector to test (default: all installed)").option("--json", "Output as JSON", false).option("--timeout <ms>", "Request timeout in milliseconds", "10000").description("Verify API credentials by making a real request to the connector's API").action(async (connector, options) => {
+  const timeout = parseInt(options.timeout, 10) || 1e4;
+  const installed = getInstalledConnectors();
+  let toTest;
+  if (connector) {
+    if (!getConnector(connector)) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: `Connector '${connector}' not found` }));
+      } else {
+        console.log(chalk2.red(`Connector '${connector}' not found`));
+      }
+      process.exit(1);
+      return;
+    }
+    toTest = [connector];
+  } else {
+    if (installed.length === 0) {
+      if (options.json) {
+        console.log(JSON.stringify({ results: [], tested: 0 }));
+      } else {
+        console.log(chalk2.dim("No connectors installed. Run: connectors install <name>"));
+      }
+      return;
+    }
+    toTest = installed;
+  }
+  if (!options.json)
+    console.log(chalk2.bold(`
+Testing connector credentials...
+`));
+  const results = [];
+  for (const name of toTest) {
+    const auth = getAuthStatus(name);
+    const endpoint = TEST_ENDPOINTS[name];
+    if (!auth.configured) {
+      results.push({ name, status: "no-key", message: "No credentials configured" });
+      if (!options.json)
+        console.log(`  ${chalk2.dim("\u25CB")} ${chalk2.dim(name)} \u2014 ${chalk2.dim("no credentials configured")}`);
+      continue;
+    }
+    if (!endpoint) {
+      results.push({ name, status: "skip", message: "No test endpoint defined" });
+      if (!options.json)
+        console.log(`  ${chalk2.dim("\u25CB")} ${chalk2.dim(name)} \u2014 ${chalk2.dim("no test endpoint (key exists)")}`);
+      continue;
+    }
+    const docs = getConnectorDocs(name);
+    const envVars = docs?.envVars || [];
+    let apiKey;
+    for (const v of envVars) {
+      if (process.env[v.variable]) {
+        apiKey = process.env[v.variable];
+        break;
+      }
+    }
+    if (!apiKey) {
+      const connectorConfigDir = join5(homedir3(), ".connectors", name.startsWith("connect-") ? name : `connect-${name}`);
+      const profileFile = join5(connectorConfigDir, "profiles", "default.json");
+      if (existsSync5(profileFile)) {
+        try {
+          const config = JSON.parse(readFileSync5(profileFile, "utf-8"));
+          apiKey = Object.values(config).find((v) => typeof v === "string" && v.length > 0);
+        } catch {}
+      }
+      if (!apiKey) {
+        const profileDirConfig = join5(connectorConfigDir, "profiles", "default", "config.json");
+        if (existsSync5(profileDirConfig)) {
+          try {
+            const config = JSON.parse(readFileSync5(profileDirConfig, "utf-8"));
+            apiKey = Object.values(config).find((v) => typeof v === "string" && v.length > 0);
+          } catch {}
+        }
+      }
+    }
+    if (!apiKey) {
+      results.push({ name, status: "no-key", message: "Credentials configured but could not extract key" });
+      if (!options.json)
+        console.log(`  ${chalk2.yellow("\u26A0")} ${chalk2.yellow(name)} \u2014 ${chalk2.dim("could not extract key")}`);
+      continue;
+    }
+    const start = Date.now();
+    try {
+      const res = await fetch(endpoint.url, {
+        method: endpoint.method || "GET",
+        headers: endpoint.headers(apiKey),
+        body: endpoint.method === "POST" ? JSON.stringify({ query: "test", num_results: 1 }) : undefined,
+        signal: AbortSignal.timeout(timeout)
+      });
+      const ms = Date.now() - start;
+      const successCodes = endpoint.successCodes || [200];
+      if (successCodes.includes(res.status) || res.status >= 200 && res.status < 300) {
+        results.push({ name, status: "pass", message: `OK (${res.status})`, ms });
+        if (!options.json)
+          console.log(`  ${chalk2.green("\u2713")} ${chalk2.green(name)} \u2014 ${chalk2.dim(`${res.status} OK`)} ${chalk2.dim(`(${ms}ms)`)}`);
+      } else {
+        const body = await res.text().catch(() => "");
+        const msg = res.status === 401 ? "Invalid or expired credentials" : `HTTP ${res.status}`;
+        results.push({ name, status: "fail", message: msg, ms });
+        if (!options.json)
+          console.log(`  ${chalk2.red("\u2717")} ${chalk2.red(name)} \u2014 ${chalk2.red(msg)} ${chalk2.dim(`(${ms}ms)`)}`);
+      }
+    } catch (e) {
+      const ms = Date.now() - start;
+      const msg = e instanceof Error ? e.message : String(e);
+      results.push({ name, status: "fail", message: msg, ms });
+      if (!options.json)
+        console.log(`  ${chalk2.red("\u2717")} ${chalk2.red(name)} \u2014 ${chalk2.red(msg)}`);
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ results, tested: results.length, passed: results.filter((r) => r.status === "pass").length }, null, 2));
+  } else {
+    const passed = results.filter((r) => r.status === "pass").length;
+    const failed = results.filter((r) => r.status === "fail").length;
+    const skipped = results.filter((r) => r.status === "skip" || r.status === "no-key").length;
+    console.log();
+    const parts = [];
+    if (passed > 0)
+      parts.push(chalk2.green(`${passed} passed`));
+    if (failed > 0)
+      parts.push(chalk2.red(`${failed} failed`));
+    if (skipped > 0)
+      parts.push(chalk2.dim(`${skipped} skipped`));
+    console.log(`  ${parts.join(", ")}
+`);
+  }
+  process.exit(results.some((r) => r.status === "fail") ? 1 : 0);
+});
 program2.parse();

package/bin/mcp.js

@@ -20275,7 +20275,7 @@ function guessKeyField(name) {
 loadConnectorVersions();
 var server = new McpServer({
   name: "connectors",
-  version: "0.2.4"
+  version: "0.2.6"
 });
 server.registerTool("search_connectors", {
   title: "Search Connectors",

package/dist/lib/test-endpoints.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Test endpoint definitions for verifying API credentials.
+ * Each entry maps a connector name to its health-check endpoint.
+ */
+export interface TestEndpoint {
+    url: string;
+    method?: string;
+    headers: (key: string) => Record<string, string>;
+    /** Expected successful status codes */
+    successCodes?: number[];
+}
+export declare const TEST_ENDPOINTS: Record<string, TestEndpoint>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/connectors",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Open source connector library - Install API connectors with a single command",
   "type": "module",
   "bin": {
@@ -26,7 +26,7 @@
   "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": "cd dashboard && bun install",
+    "postinstall": "[ \"$SKIP_DASHBOARD\" = \"1\" ] || [ -d dashboard/node_modules ] || (cd dashboard && bun install)",
     "dev": "bun run ./src/cli/index.tsx",
     "typecheck": "tsc --noEmit",
     "test": "bun test",