@hasna/connectors 0.0.6 → 0.1.0

package/bin/serve.js

@@ -0,0 +1,1056 @@
+#!/usr/bin/env bun
+// @bun
+var __require = import.meta.require;
+
+// src/server/serve.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4, dirname as dirname3, extname } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/lib/registry.ts
+import { existsSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var CONNECTORS = [
+  {
+    name: "anthropic",
+    displayName: "Anthropic",
+    description: "Claude AI models and API",
+    category: "AI & ML",
+    tags: ["ai", "llm", "claude"]
+  },
+  {
+    name: "openai",
+    displayName: "OpenAI",
+    description: "GPT models, DALL-E, and Whisper",
+    category: "AI & ML",
+    tags: ["ai", "llm", "gpt", "dalle"]
+  },
+  {
+    name: "xai",
+    displayName: "xAI",
+    description: "Grok AI models",
+    category: "AI & ML",
+    tags: ["ai", "llm", "grok"]
+  },
+  {
+    name: "mistral",
+    displayName: "Mistral",
+    description: "Mistral AI models",
+    category: "AI & ML",
+    tags: ["ai", "llm"]
+  },
+  {
+    name: "googlegemini",
+    displayName: "Google Gemini",
+    description: "Gemini AI models",
+    category: "AI & ML",
+    tags: ["ai", "llm", "google"]
+  },
+  {
+    name: "huggingface",
+    displayName: "Hugging Face",
+    description: "ML models and datasets hub",
+    category: "AI & ML",
+    tags: ["ai", "ml", "models"]
+  },
+  {
+    name: "stabilityai",
+    displayName: "Stability AI",
+    description: "Stable Diffusion image generation",
+    category: "AI & ML",
+    tags: ["ai", "image", "generation"]
+  },
+  {
+    name: "midjourney",
+    displayName: "Midjourney",
+    description: "AI image generation",
+    category: "AI & ML",
+    tags: ["ai", "image", "generation"]
+  },
+  {
+    name: "heygen",
+    displayName: "HeyGen",
+    description: "AI video generation",
+    category: "AI & ML",
+    tags: ["ai", "video", "avatar"]
+  },
+  {
+    name: "hedra",
+    displayName: "Hedra",
+    description: "AI video generation",
+    category: "AI & ML",
+    tags: ["ai", "video"]
+  },
+  {
+    name: "elevenlabs",
+    displayName: "ElevenLabs",
+    description: "AI voice synthesis and cloning",
+    category: "AI & ML",
+    tags: ["ai", "voice", "tts"]
+  },
+  {
+    name: "reducto",
+    displayName: "Reducto",
+    description: "Document processing and extraction",
+    category: "AI & ML",
+    tags: ["ai", "document", "ocr"]
+  },
+  {
+    name: "github",
+    displayName: "GitHub",
+    description: "Repositories, issues, PRs, and actions",
+    category: "Developer Tools",
+    tags: ["git", "code", "vcs"]
+  },
+  {
+    name: "docker",
+    displayName: "Docker",
+    description: "Container management and registry",
+    category: "Developer Tools",
+    tags: ["containers", "devops"]
+  },
+  {
+    name: "sentry",
+    displayName: "Sentry",
+    description: "Error tracking and monitoring",
+    category: "Developer Tools",
+    tags: ["monitoring", "errors"]
+  },
+  {
+    name: "cloudflare",
+    displayName: "Cloudflare",
+    description: "DNS, CDN, and edge computing",
+    category: "Developer Tools",
+    tags: ["cdn", "dns", "edge"]
+  },
+  {
+    name: "googlecloud",
+    displayName: "Google Cloud",
+    description: "GCP services and APIs",
+    category: "Developer Tools",
+    tags: ["cloud", "gcp"]
+  },
+  {
+    name: "aws",
+    displayName: "AWS",
+    description: "Amazon Web Services",
+    category: "Developer Tools",
+    tags: ["cloud", "aws"]
+  },
+  {
+    name: "e2b",
+    displayName: "E2B",
+    description: "Code interpreter sandboxes",
+    category: "Developer Tools",
+    tags: ["sandbox", "code"]
+  },
+  {
+    name: "firecrawl",
+    displayName: "Firecrawl",
+    description: "Web scraping and crawling",
+    category: "Developer Tools",
+    tags: ["scraping", "web"]
+  },
+  {
+    name: "browseruse",
+    displayName: "Browser Use",
+    description: "Browser automation for AI",
+    category: "Developer Tools",
+    tags: ["browser", "automation"]
+  },
+  {
+    name: "shadcn",
+    displayName: "shadcn/ui",
+    description: "UI component registry",
+    category: "Developer Tools",
+    tags: ["ui", "components", "react"]
+  },
+  {
+    name: "figma",
+    displayName: "Figma",
+    description: "Design files, components, and comments",
+    category: "Design & Content",
+    tags: ["design", "ui"]
+  },
+  {
+    name: "webflow",
+    displayName: "Webflow",
+    description: "Website builder and CMS",
+    category: "Design & Content",
+    tags: ["website", "cms"]
+  },
+  {
+    name: "wix",
+    displayName: "Wix",
+    description: "Website builder",
+    category: "Design & Content",
+    tags: ["website"]
+  },
+  {
+    name: "icons8",
+    displayName: "Icons8",
+    description: "Icons and illustrations",
+    category: "Design & Content",
+    tags: ["icons", "assets"]
+  },
+  {
+    name: "gmail",
+    displayName: "Gmail",
+    description: "Email sending and management",
+    category: "Communication",
+    tags: ["email", "google"]
+  },
+  {
+    name: "discord",
+    displayName: "Discord",
+    description: "Messaging and communities",
+    category: "Communication",
+    tags: ["chat", "community"]
+  },
+  {
+    name: "twilio",
+    displayName: "Twilio",
+    description: "SMS, voice, and messaging",
+    category: "Communication",
+    tags: ["sms", "voice"]
+  },
+  {
+    name: "resend",
+    displayName: "Resend",
+    description: "Email API for developers",
+    category: "Communication",
+    tags: ["email", "api"]
+  },
+  {
+    name: "zoom",
+    displayName: "Zoom",
+    description: "Video meetings and webinars",
+    category: "Communication",
+    tags: ["video", "meetings"]
+  },
+  {
+    name: "maropost",
+    displayName: "Maropost",
+    description: "Email marketing automation",
+    category: "Communication",
+    tags: ["email", "marketing"]
+  },
+  {
+    name: "x",
+    displayName: "X (Twitter)",
+    description: "Posts, threads, and engagement",
+    category: "Social Media",
+    tags: ["social", "twitter"]
+  },
+  {
+    name: "reddit",
+    displayName: "Reddit",
+    description: "Posts, comments, and subreddits",
+    category: "Social Media",
+    tags: ["social", "community"]
+  },
+  {
+    name: "substack",
+    displayName: "Substack",
+    description: "Newsletter publishing",
+    category: "Social Media",
+    tags: ["newsletter", "writing"]
+  },
+  {
+    name: "meta",
+    displayName: "Meta",
+    description: "Facebook and Instagram APIs",
+    category: "Social Media",
+    tags: ["social", "facebook", "instagram"]
+  },
+  {
+    name: "snap",
+    displayName: "Snapchat",
+    description: "Snapchat marketing API",
+    category: "Social Media",
+    tags: ["social", "ads"]
+  },
+  {
+    name: "tiktok",
+    displayName: "TikTok",
+    description: "TikTok content and ads",
+    category: "Social Media",
+    tags: ["social", "video"]
+  },
+  {
+    name: "youtube",
+    displayName: "YouTube",
+    description: "Videos, channels, and analytics",
+    category: "Social Media",
+    tags: ["video", "google"]
+  },
+  {
+    name: "stripe",
+    displayName: "Stripe",
+    description: "Payments, subscriptions, and billing",
+    category: "Commerce & Finance",
+    tags: ["payments", "billing"]
+  },
+  {
+    name: "stripeatlas",
+    displayName: "Stripe Atlas",
+    description: "Company incorporation",
+    category: "Commerce & Finance",
+    tags: ["incorporation", "business"]
+  },
+  {
+    name: "shopify",
+    displayName: "Shopify",
+    description: "E-commerce platform",
+    category: "Commerce & Finance",
+    tags: ["ecommerce", "store"]
+  },
+  {
+    name: "revolut",
+    displayName: "Revolut",
+    description: "Banking and payments",
+    category: "Commerce & Finance",
+    tags: ["banking", "fintech"]
+  },
+  {
+    name: "mercury",
+    displayName: "Mercury",
+    description: "Startup banking",
+    category: "Commerce & Finance",
+    tags: ["banking", "startup"]
+  },
+  {
+    name: "pandadoc",
+    displayName: "PandaDoc",
+    description: "Document signing and proposals",
+    category: "Commerce & Finance",
+    tags: ["documents", "esign"]
+  },
+  {
+    name: "google",
+    displayName: "Google",
+    description: "Google OAuth and APIs",
+    category: "Google Workspace",
+    tags: ["google", "auth"]
+  },
+  {
+    name: "googledrive",
+    displayName: "Google Drive",
+    description: "File storage and sharing",
+    category: "Google Workspace",
+    tags: ["storage", "google"]
+  },
+  {
+    name: "googledocs",
+    displayName: "Google Docs",
+    description: "Document creation and editing",
+    category: "Google Workspace",
+    tags: ["documents", "google"]
+  },
+  {
+    name: "googlesheets",
+    displayName: "Google Sheets",
+    description: "Spreadsheets and data",
+    category: "Google Workspace",
+    tags: ["spreadsheets", "google"]
+  },
+  {
+    name: "googlecalendar",
+    displayName: "Google Calendar",
+    description: "Calendar and events",
+    category: "Google Workspace",
+    tags: ["calendar", "google"]
+  },
+  {
+    name: "googletasks",
+    displayName: "Google Tasks",
+    description: "Task management",
+    category: "Google Workspace",
+    tags: ["tasks", "google"]
+  },
+  {
+    name: "googlecontacts",
+    displayName: "Google Contacts",
+    description: "Contact management",
+    category: "Google Workspace",
+    tags: ["contacts", "google"]
+  },
+  {
+    name: "googlemaps",
+    displayName: "Google Maps",
+    description: "Maps, places, and directions",
+    category: "Google Workspace",
+    tags: ["maps", "google"]
+  },
+  {
+    name: "exa",
+    displayName: "Exa",
+    description: "AI-powered web search",
+    category: "Data & Analytics",
+    tags: ["search", "ai"]
+  },
+  {
+    name: "mixpanel",
+    displayName: "Mixpanel",
+    description: "Product analytics",
+    category: "Data & Analytics",
+    tags: ["analytics", "product"]
+  },
+  {
+    name: "openweathermap",
+    displayName: "OpenWeatherMap",
+    description: "Weather data and forecasts",
+    category: "Data & Analytics",
+    tags: ["weather", "data"]
+  },
+  {
+    name: "brandsight",
+    displayName: "Brandsight",
+    description: "Brand monitoring",
+    category: "Data & Analytics",
+    tags: ["brand", "monitoring"]
+  },
+  {
+    name: "notion",
+    displayName: "Notion",
+    description: "Pages, databases, blocks, and property management",
+    category: "Business Tools",
+    tags: ["productivity", "databases", "wiki", "notes"]
+  },
+  {
+    name: "quo",
+    displayName: "Quo",
+    description: "Business quotes and invoices",
+    category: "Business Tools",
+    tags: ["invoices", "quotes"]
+  },
+  {
+    name: "tinker",
+    displayName: "Tinker",
+    description: "Internal tooling",
+    category: "Business Tools",
+    tags: ["internal", "tools"]
+  },
+  {
+    name: "sedo",
+    displayName: "Sedo",
+    description: "Domain marketplace",
+    category: "Business Tools",
+    tags: ["domains", "marketplace"]
+  },
+  {
+    name: "uspto",
+    displayName: "USPTO",
+    description: "US Patent and Trademark Office",
+    category: "Patents & IP",
+    tags: ["patents", "trademarks", "ip"]
+  },
+  {
+    name: "xads",
+    displayName: "X Ads",
+    description: "Twitter/X advertising",
+    category: "Advertising",
+    tags: ["ads", "twitter"]
+  }
+];
+function getConnector(name) {
+  return CONNECTORS.find((c) => c.name === name);
+}
+var versionsLoaded = false;
+function loadConnectorVersions() {
+  if (versionsLoaded)
+    return;
+  versionsLoaded = true;
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(thisDir, "..", "connectors"),
+    join(thisDir, "..", "..", "connectors")
+  ];
+  const connectorsDir = candidates.find((d) => existsSync(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"));
+        connector.version = pkg.version || "0.0.0";
+      }
+    } catch {}
+  }
+}
+
+// src/lib/installer.ts
+import { existsSync as existsSync2, cpSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+function resolveConnectorsDir() {
+  const fromBin = join2(__dirname2, "..", "connectors");
+  if (existsSync2(fromBin))
+    return fromBin;
+  const fromSrc = join2(__dirname2, "..", "..", "connectors");
+  if (existsSync2(fromSrc))
+    return fromSrc;
+  return fromBin;
+}
+var CONNECTORS_DIR = resolveConnectorsDir();
+function getConnectorPath(name) {
+  const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
+  return join2(CONNECTORS_DIR, connectorName);
+}
+function getInstalledConnectors(targetDir = process.cwd()) {
+  const connectorsDir = join2(targetDir, ".connectors");
+  if (!existsSync2(connectorsDir)) {
+    return [];
+  }
+  const { readdirSync, statSync } = __require("fs");
+  return readdirSync(connectorsDir).filter((f) => {
+    const fullPath = join2(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))
+    return null;
+  const raw = readFileSync2(claudeMdPath, "utf-8");
+  return {
+    overview: extractSection(raw, "Project Overview"),
+    auth: extractSection(raw, "Authentication"),
+    envVars: parseEnvVarsTable(extractSection(raw, "Environment Variables")),
+    cliCommands: extractSection(raw, "CLI Commands"),
+    dataStorage: extractSection(raw, "Data Storage"),
+    raw
+  };
+}
+function extractSection(markdown, heading) {
+  const regex = new RegExp(`^##\\s+${escapeRegex(heading)}\\s*$`, "m");
+  const match = regex.exec(markdown);
+  if (!match)
+    return "";
+  const start = match.index + match[0].length;
+  const nextHeading = markdown.slice(start).search(/^##\s/m);
+  const content = nextHeading === -1 ? markdown.slice(start) : markdown.slice(start, start + nextHeading);
+  return content.trim();
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseEnvVarsTable(section) {
+  if (!section)
+    return [];
+  const vars = [];
+  const lines = section.split(`
+`);
+  for (const line of lines) {
+    const match = line.match(/\|\s*`([^`]+)`\s*\|\s*(.+?)\s*\|/);
+    if (match && match[1] !== "Variable") {
+      vars.push({ variable: match[1], description: match[2].trim() });
+    }
+  }
+  return vars;
+}
+
+// src/server/auth.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { homedir } from "os";
+import { join as join3 } from "path";
+var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+var GOOGLE_SCOPES = {
+  gmail: [
+    "https://www.googleapis.com/auth/gmail.readonly",
+    "https://www.googleapis.com/auth/gmail.send",
+    "https://www.googleapis.com/auth/gmail.compose",
+    "https://www.googleapis.com/auth/gmail.modify",
+    "https://www.googleapis.com/auth/gmail.labels",
+    "https://mail.google.com/"
+  ].join(" "),
+  googlecalendar: [
+    "https://www.googleapis.com/auth/calendar",
+    "https://www.googleapis.com/auth/calendar.events"
+  ].join(" "),
+  googledrive: [
+    "https://www.googleapis.com/auth/drive",
+    "https://www.googleapis.com/auth/drive.file"
+  ].join(" "),
+  googledocs: [
+    "https://www.googleapis.com/auth/documents",
+    "https://www.googleapis.com/auth/drive.file"
+  ].join(" "),
+  googlesheets: [
+    "https://www.googleapis.com/auth/spreadsheets",
+    "https://www.googleapis.com/auth/drive.file"
+  ].join(" "),
+  googletasks: [
+    "https://www.googleapis.com/auth/tasks"
+  ].join(" "),
+  googlecontacts: [
+    "https://www.googleapis.com/auth/contacts",
+    "https://www.googleapis.com/auth/contacts.readonly"
+  ].join(" "),
+  google: [
+    "openid",
+    "https://www.googleapis.com/auth/userinfo.email",
+    "https://www.googleapis.com/auth/userinfo.profile"
+  ].join(" ")
+};
+function getAuthType(name) {
+  const docs = getConnectorDocs(name);
+  if (!docs?.auth)
+    return "apikey";
+  const authLower = docs.auth.toLowerCase();
+  if (authLower.includes("oauth"))
+    return "oauth";
+  if (authLower.includes("bearer token"))
+    return "bearer";
+  return "apikey";
+}
+function getConnectorConfigDir(name) {
+  const connectorName = name.startsWith("connect-") ? name : `connect-${name}`;
+  return join3(homedir(), ".connect", connectorName);
+}
+function getCurrentProfile(name) {
+  const configDir = getConnectorConfigDir(name);
+  const currentProfileFile = join3(configDir, "current_profile");
+  if (existsSync3(currentProfileFile)) {
+    try {
+      return readFileSync3(currentProfileFile, "utf-8").trim() || "default";
+    } catch {
+      return "default";
+    }
+  }
+  return "default";
+}
+function loadProfileConfig(name) {
+  const configDir = getConnectorConfigDir(name);
+  const profile = getCurrentProfile(name);
+  const profileFile = join3(configDir, "profiles", `${profile}.json`);
+  if (existsSync3(profileFile)) {
+    try {
+      return JSON.parse(readFileSync3(profileFile, "utf-8"));
+    } catch {}
+  }
+  const profileDirConfig = join3(configDir, "profiles", profile, "config.json");
+  if (existsSync3(profileDirConfig)) {
+    try {
+      return JSON.parse(readFileSync3(profileDirConfig, "utf-8"));
+    } catch {}
+  }
+  return {};
+}
+function loadTokens(name) {
+  const configDir = getConnectorConfigDir(name);
+  const profile = getCurrentProfile(name);
+  const tokensFile = join3(configDir, "profiles", profile, "tokens.json");
+  if (existsSync3(tokensFile)) {
+    try {
+      return JSON.parse(readFileSync3(tokensFile, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function getAuthStatus(name) {
+  const authType = getAuthType(name);
+  const docs = getConnectorDocs(name);
+  const envVars = (docs?.envVars || []).map((v) => ({
+    variable: v.variable,
+    description: v.description,
+    set: !!process.env[v.variable]
+  }));
+  if (authType === "oauth") {
+    const tokens = loadTokens(name);
+    const config2 = loadProfileConfig(name);
+    const hasTokens = !!tokens?.accessToken;
+    const hasRefreshToken = !!tokens?.refreshToken;
+    const tokenExpiry = tokens?.expiresAt;
+    return {
+      type: "oauth",
+      configured: hasTokens || hasRefreshToken,
+      tokenExpiry,
+      hasRefreshToken,
+      envVars
+    };
+  }
+  const config = loadProfileConfig(name);
+  const hasKey = Object.values(config).some((v) => typeof v === "string" && v.length > 0);
+  const hasEnvVar = envVars.some((v) => v.set);
+  return {
+    type: authType,
+    configured: hasKey || hasEnvVar,
+    envVars
+  };
+}
+function saveApiKey(name, key, field) {
+  const configDir = getConnectorConfigDir(name);
+  const profile = getCurrentProfile(name);
+  const keyField = field || guessKeyField(name);
+  const profileFile = join3(configDir, "profiles", `${profile}.json`);
+  const profileDir = join3(configDir, "profiles", profile);
+  if (existsSync3(profileFile)) {
+    const config = JSON.parse(readFileSync3(profileFile, "utf-8"));
+    config[keyField] = key;
+    writeFileSync2(profileFile, JSON.stringify(config, null, 2));
+    return;
+  }
+  if (existsSync3(profileDir)) {
+    const configFile = join3(profileDir, "config.json");
+    const config = existsSync3(configFile) ? JSON.parse(readFileSync3(configFile, "utf-8")) : {};
+    config[keyField] = key;
+    writeFileSync2(configFile, JSON.stringify(config, null, 2));
+    return;
+  }
+  mkdirSync2(join3(configDir, "profiles"), { recursive: true });
+  writeFileSync2(profileFile, JSON.stringify({ [keyField]: key }, null, 2));
+}
+function guessKeyField(name) {
+  const docs = getConnectorDocs(name);
+  if (!docs?.envVars.length)
+    return "apiKey";
+  const keyVar = docs.envVars.find((v) => v.variable.includes("API_KEY") || v.variable.includes("API_SECRET") || v.variable.includes("TOKEN") || v.variable.includes("SECRET"));
+  if (keyVar) {
+    const parts = keyVar.variable.toLowerCase().split("_");
+    const withoutPrefix = parts.slice(1);
+    if (withoutPrefix.length > 0) {
+      return withoutPrefix.map((p, i) => i === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1)).join("");
+    }
+  }
+  return "apiKey";
+}
+function getOAuthConfig(name) {
+  const configDir = getConnectorConfigDir(name);
+  const credentialsFile = join3(configDir, "credentials.json");
+  if (existsSync3(credentialsFile)) {
+    try {
+      const creds = JSON.parse(readFileSync3(credentialsFile, "utf-8"));
+      return { clientId: creds.clientId, clientSecret: creds.clientSecret };
+    } catch {}
+  }
+  const config = loadProfileConfig(name);
+  return {
+    clientId: config.clientId,
+    clientSecret: config.clientSecret
+  };
+}
+function getOAuthStartUrl(name, redirectUri) {
+  const oauthConfig = getOAuthConfig(name);
+  if (!oauthConfig.clientId)
+    return null;
+  const scopes = GOOGLE_SCOPES[name];
+  if (!scopes)
+    return null;
+  const params = new URLSearchParams({
+    client_id: oauthConfig.clientId,
+    redirect_uri: redirectUri,
+    response_type: "code",
+    scope: scopes,
+    access_type: "offline",
+    prompt: "consent"
+  });
+  return `${GOOGLE_AUTH_URL}?${params.toString()}`;
+}
+async function exchangeOAuthCode(name, code, redirectUri) {
+  const oauthConfig = getOAuthConfig(name);
+  if (!oauthConfig.clientId || !oauthConfig.clientSecret) {
+    throw new Error("OAuth credentials not configured for " + name);
+  }
+  const response = await fetch(GOOGLE_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      code,
+      client_id: oauthConfig.clientId,
+      client_secret: oauthConfig.clientSecret,
+      redirect_uri: redirectUri,
+      grant_type: "authorization_code"
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: response.statusText }));
+    throw new Error(`Token exchange failed: ${error.error_description || error.error || response.statusText}`);
+  }
+  const data = await response.json();
+  const tokens = {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1000,
+    tokenType: data.token_type,
+    scope: data.scope
+  };
+  saveOAuthTokens(name, tokens);
+  return tokens;
+}
+function saveOAuthTokens(name, tokens) {
+  const configDir = getConnectorConfigDir(name);
+  const profile = getCurrentProfile(name);
+  const profileDir = join3(configDir, "profiles", profile);
+  mkdirSync2(profileDir, { recursive: true });
+  const tokensFile = join3(profileDir, "tokens.json");
+  writeFileSync2(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+async function refreshOAuthToken(name) {
+  const oauthConfig = getOAuthConfig(name);
+  const currentTokens = loadTokens(name);
+  if (!oauthConfig.clientId || !oauthConfig.clientSecret) {
+    throw new Error("OAuth credentials not configured for " + name);
+  }
+  if (!currentTokens?.refreshToken) {
+    throw new Error("No refresh token available. Please re-authenticate.");
+  }
+  const response = await fetch(GOOGLE_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: oauthConfig.clientId,
+      client_secret: oauthConfig.clientSecret,
+      refresh_token: currentTokens.refreshToken,
+      grant_type: "refresh_token"
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: response.statusText }));
+    throw new Error(`Token refresh failed: ${error.error_description || error.error}`);
+  }
+  const data = await response.json();
+  const tokens = {
+    accessToken: data.access_token,
+    refreshToken: currentTokens.refreshToken,
+    expiresAt: Date.now() + data.expires_in * 1000,
+    tokenType: data.token_type,
+    scope: data.scope || currentTokens.scope
+  };
+  saveOAuthTokens(name, tokens);
+  return tokens;
+}
+
+// src/server/serve.ts
+function resolveDashboardDir() {
+  const candidates = [];
+  try {
+    const scriptDir = dirname3(fileURLToPath3(import.meta.url));
+    candidates.push(join4(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join4(scriptDir, "..", "..", "dashboard", "dist"));
+  } catch {}
+  if (process.argv[1]) {
+    const mainDir = dirname3(process.argv[1]);
+    candidates.push(join4(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join4(mainDir, "..", "..", "dashboard", "dist"));
+  }
+  candidates.push(join4(process.cwd(), "dashboard", "dist"));
+  for (const candidate of candidates) {
+    if (existsSync4(candidate))
+      return candidate;
+  }
+  return join4(process.cwd(), "dashboard", "dist");
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
+  });
+}
+function htmlResponse(content, status = 200) {
+  return new Response(content, {
+    status,
+    headers: { "Content-Type": "text/html; charset=utf-8" }
+  });
+}
+function getAllConnectorsWithAuth() {
+  const installed = new Set(getInstalledConnectors());
+  return CONNECTORS.map((meta) => {
+    const isInstalled = installed.has(meta.name);
+    const auth = isInstalled ? getAuthStatus(meta.name) : null;
+    return {
+      name: meta.name,
+      displayName: meta.displayName,
+      description: meta.description,
+      category: meta.category,
+      version: meta.version,
+      installed: isInstalled,
+      auth
+    };
+  });
+}
+function errorPage(title, message, hint) {
+  return `<!DOCTYPE html><html><head><meta charset="utf-8"></head><body style="font-family:system-ui,sans-serif;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:var(--bg,#0a0a0a);color:var(--fg,#e5e5e5);">
+    <style>@media(prefers-color-scheme:light){:root{--bg:#fff;--fg:#111;--sub:#666;--hint:#888}}:root{--bg:#0a0a0a;--fg:#e5e5e5;--sub:#888;--hint:#666}</style>
+    <div style="text-align:center;">
+      <h2 style="color:#ef4444;">${title}</h2>
+      <p style="color:var(--sub);">${message}</p>
+      ${hint ? `<p style="color:var(--hint);font-size:14px;">${hint}</p>` : ""}
+    </div>
+  </body></html>`;
+}
+function serveStaticFile(filePath) {
+  if (!existsSync4(filePath))
+    return null;
+  const ext = extname(filePath);
+  const contentType = MIME_TYPES[ext] || "application/octet-stream";
+  return new Response(Bun.file(filePath), {
+    headers: { "Content-Type": contentType }
+  });
+}
+async function startServer(port, options) {
+  const shouldOpen = options?.open ?? true;
+  loadConnectorVersions();
+  const dashboardDir = resolveDashboardDir();
+  const dashboardExists = existsSync4(dashboardDir);
+  if (!dashboardExists) {
+    console.error(`Dashboard not built at ${dashboardDir}. Run: cd dashboard && bun run build`);
+  }
+  const server = Bun.serve({
+    port,
+    async fetch(req) {
+      const url2 = new URL(req.url);
+      const path = url2.pathname;
+      const method = req.method;
+      if (path === "/api/connectors" && method === "GET") {
+        return json(getAllConnectorsWithAuth());
+      }
+      const singleMatch = path.match(/^\/api\/connectors\/([^/]+)$/);
+      if (singleMatch && method === "GET") {
+        const name = singleMatch[1];
+        const meta = getConnector(name);
+        if (!meta)
+          return json({ error: `Connector '${name}' not found` }, 404);
+        const auth = getAuthStatus(name);
+        const docs = getConnectorDocs(name);
+        return json({
+          name: meta.name,
+          displayName: meta.displayName,
+          description: meta.description,
+          category: meta.category,
+          version: meta.version,
+          auth,
+          overview: docs?.overview || null
+        });
+      }
+      const keyMatch = path.match(/^\/api\/connectors\/([^/]+)\/key$/);
+      if (keyMatch && method === "POST") {
+        const name = keyMatch[1];
+        try {
+          const body = await req.json();
+          if (!body.key)
+            return json({ error: "Missing 'key' in request body" }, 400);
+          saveApiKey(name, body.key, body.field);
+          return json({ success: true });
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to save key" }, 500);
+        }
+      }
+      const refreshMatch = path.match(/^\/api\/connectors\/([^/]+)\/refresh$/);
+      if (refreshMatch && method === "POST") {
+        const name = refreshMatch[1];
+        try {
+          const tokens = await refreshOAuthToken(name);
+          return json({ success: true, expiresAt: tokens.expiresAt });
+        } catch (e) {
+          return json({ success: false, error: e instanceof Error ? e.message : "Failed to refresh" }, 500);
+        }
+      }
+      const oauthStartMatch = path.match(/^\/oauth\/([^/]+)\/start$/);
+      if (oauthStartMatch && method === "GET") {
+        const name = oauthStartMatch[1];
+        const redirectUri = `http://localhost:${port}/oauth/${name}/callback`;
+        const authUrl = getOAuthStartUrl(name, redirectUri);
+        if (!authUrl) {
+          return htmlResponse(errorPage("OAuth Not Available", `No OAuth client credentials found for <strong>${name}</strong>.`, `Set up credentials at <code>~/.connect/connect-${name}/credentials.json</code>`));
+        }
+        return Response.redirect(authUrl, 302);
+      }
+      const oauthCallbackMatch = path.match(/^\/oauth\/([^/]+)\/callback$/);
+      if (oauthCallbackMatch && method === "GET") {
+        const name = oauthCallbackMatch[1];
+        const code = url2.searchParams.get("code");
+        const error = url2.searchParams.get("error");
+        if (error) {
+          return htmlResponse(errorPage("Authentication Failed", error, "You can close this window."));
+        }
+        if (!code) {
+          return htmlResponse(errorPage("Missing Authorization Code", "No code received from the OAuth provider.", "You can close this window and try again."));
+        }
+        try {
+          const redirectUri = `http://localhost:${port}/oauth/${name}/callback`;
+          await exchangeOAuthCode(name, code, redirectUri);
+          return htmlResponse(`<!DOCTYPE html><html><head><meta charset="utf-8"></head><body style="font-family:system-ui,sans-serif;display:flex;justify-content:center;align-items:center;height:100vh;margin:0;background:#0a0a0a;color:#e5e5e5;">
+            <div style="text-align:center;">
+              <h2 style="color:#22c55e;">Connected!</h2>
+              <p style="color:#888;"><strong>${name}</strong> is now authenticated.</p>
+              <p style="color:#666;font-size:14px;">You can close this window and return to the dashboard.</p>
+              <script>
+                if (window.opener) {
+                  window.opener.postMessage({ type: 'oauth-complete', connector: '${name}' }, '*');
+                }
+              </script>
+            </div>
+          </body></html>`);
+        } catch (e) {
+          return htmlResponse(errorPage("Authentication Failed", e instanceof Error ? e.message : "Unknown error", "You can close this window."));
+        }
+      }
+      if (method === "OPTIONS") {
+        return new Response(null, {
+          headers: {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type"
+          }
+        });
+      }
+      if (dashboardExists && (method === "GET" || method === "HEAD")) {
+        if (path !== "/") {
+          const filePath = join4(dashboardDir, path);
+          const res2 = serveStaticFile(filePath);
+          if (res2)
+            return res2;
+        }
+        const indexPath = join4(dashboardDir, "index.html");
+        const res = serveStaticFile(indexPath);
+        if (res)
+          return res;
+      }
+      return json({ error: "Not found" }, 404);
+    }
+  });
+  const url = `http://localhost:${port}`;
+  console.log(`Connectors Dashboard running at ${url}`);
+  if (shouldOpen) {
+    try {
+      const { exec } = await import("child_process");
+      const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      exec(`${openCmd} ${url}`);
+    } catch {}
+  }
+}
+
+// src/server/index.ts
+var DEFAULT_PORT = 19426;
+function parsePort() {
+  const portArg = process.argv.find((a) => a === "--port" || a.startsWith("--port="));
+  if (portArg) {
+    if (portArg.includes("=")) {
+      return parseInt(portArg.split("=")[1], 10) || DEFAULT_PORT;
+    }
+    const idx = process.argv.indexOf(portArg);
+    return parseInt(process.argv[idx + 1], 10) || DEFAULT_PORT;
+  }
+  return DEFAULT_PORT;
+}
+startServer(parsePort());