@openhands/extensions 0.0.1-alpha

package/integrations/catalog/tavily.json

@@ -0,0 +1,46 @@
+{
+  "id": "tavily",
+  "name": "Tavily",
+  "description": "Production-grade web search optimized for LLM agents. Free tier available.",
+  "docsUrl": "https://github.com/tavily-ai/tavily-mcp",
+  "iconBg": "#2563EB",
+  "keywords": [
+    "search",
+    "web",
+    "browsing",
+    "research"
+  ],
+  "popularityRank": 90,
+  "installHint": "Paste your Tavily API key - the official tavily-mcp package runs via npx.",
+  "kind": "mcp",
+  "defaultConnectionOptionId": "api",
+  "connectionOptions": [
+    {
+      "id": "api",
+      "provider": "mcp",
+      "transport": {
+        "kind": "stdio",
+        "serverName": "tavily",
+        "command": "npx",
+        "args": [
+          "-y",
+          "tavily-mcp"
+        ],
+        "envFields": [
+          {
+            "key": "TAVILY_API_KEY",
+            "label": "Tavily API key",
+            "type": "password",
+            "placeholder": "tvly-...",
+            "required": true,
+            "helperText": "API key from your Tavily dashboard.",
+            "helperLink": "https://app.tavily.com/home?tab=keys"
+          }
+        ]
+      },
+      "auth": {
+        "strategy": "api_key"
+      }
+    }
+  ]
+}

package/integrations/catalog/time.json

@@ -0,0 +1,31 @@
+{
+  "id": "time",
+  "name": "Time",
+  "description": "Timezone-aware current time, conversions, and timestamp formatting.",
+  "docsUrl": "https://github.com/modelcontextprotocol/servers/tree/main/src/time",
+  "iconBg": "var(--oh-surface)",
+  "keywords": [
+    "clock",
+    "timezone",
+    "date"
+  ],
+  "kind": "mcp",
+  "defaultConnectionOptionId": "none",
+  "connectionOptions": [
+    {
+      "id": "none",
+      "provider": "mcp",
+      "transport": {
+        "kind": "stdio",
+        "serverName": "time",
+        "command": "uvx",
+        "args": [
+          "mcp-server-time"
+        ]
+      },
+      "auth": {
+        "strategy": "none"
+      }
+    }
+  ]
+}

package/integrations/index.d.ts

@@ -0,0 +1,167 @@
+export type MarketplaceFieldType = "text" | "password";
+
+export interface MarketplaceField {
+  key: string;
+  label: string;
+  type?: MarketplaceFieldType;
+  placeholder?: string;
+  helperText?: string;
+  helperLink?: string;
+  required?: boolean;
+}
+
+export type IntegrationTransport =
+  | {
+      kind: "shttp";
+      url: string;
+      apiKeyOptional?: boolean;
+    }
+  | {
+      kind: "sse";
+      url: string;
+      apiKeyOptional?: boolean;
+    }
+  | {
+      kind: "stdio";
+      serverName: string;
+      command: string;
+      args: string[];
+      envFields?: MarketplaceField[];
+      argFields?: MarketplaceField[];
+    };
+
+export type IntegrationAuthStrategy =
+  | "none"
+  | "api_key"
+  | "bearer"
+  | "basic"
+  | "oauth2";
+
+export type IntegrationProvider = "mcp" | "http";
+
+export interface IntegrationOAuthConfig {
+  authorizationUrl?: string;
+  tokenUrl?: string;
+  scopes?: string[];
+  optionalScopes?: string[];
+  toolScopes?: string[];
+  scopeSeparator?: "space" | "comma";
+  pkce?: boolean;
+  clientAuthentication?: "basic" | "body" | "none";
+  registrationUrl?: string;
+  additionalAuthorizationParams?: Record<string, string>;
+  additionalTokenParams?: Record<string, string>;
+}
+
+export interface IntegrationAuthConfig {
+  strategy: IntegrationAuthStrategy;
+  authModes?: IntegrationAuthStrategy[];
+  credentialLabel?: string;
+  credentialPlaceholder?: string;
+  credentialHelp?: string;
+  apiKeyHeaderName?: string;
+  apiKeyOptional?: boolean;
+  oauth?: IntegrationOAuthConfig;
+}
+
+export interface IntegrationHttpDefaultTool {
+  name: string;
+  description?: string;
+  method?: string;
+  path?: string;
+  scopes?: string[];
+}
+
+export interface IntegrationHttpConfig {
+  apiBaseUrl?: string;
+  openApiUrl?: string;
+  defaultTool?: IntegrationHttpDefaultTool;
+}
+
+export interface IntegrationConnectionOption {
+  id: "oauth" | "api" | "none" | string;
+  provider: IntegrationProvider;
+  transport?: IntegrationTransport;
+  http?: IntegrationHttpConfig;
+  auth: IntegrationAuthConfig;
+}
+
+export interface OAuthProviderRegistrationDefaults {
+  provider?: IntegrationProvider;
+  authModes?: IntegrationAuthStrategy[];
+  authStrategy?: IntegrationAuthStrategy;
+  credentialLabel?: string;
+  credentialPlaceholder?: string;
+  credentialHelp?: string;
+  apiKeyHeaderName?: string;
+  apiBaseUrl?: string;
+  serverUrl?: string;
+  openApiUrl?: string;
+  authorizationUrl?: string;
+  tokenUrl?: string;
+  scopes?: string[];
+  optionalScopes?: string[];
+  toolScopes?: string[];
+  scopeSeparator?: "space" | "comma";
+  pkce?: boolean;
+  clientAuthentication?: "basic" | "body" | "none";
+  registrationUrl?: string;
+  additionalAuthorizationParams?: Record<string, string>;
+  additionalTokenParams?: Record<string, string>;
+  toolName?: string;
+  toolDescription?: string;
+  requestMethod?: string;
+  requestPath?: string;
+}
+
+export interface OAuthProviderCatalogOption {
+  slug: string;
+  name: string;
+  description: string;
+  categories: string[];
+  authStrategy: IntegrationAuthStrategy;
+  availability: "oauth_ready" | "manual_token" | "planned";
+  managedConnectorSlug?: string;
+  appUrl?: string;
+  docsUrl?: string;
+  notes: string;
+  popularityRank: number;
+  registrationDefaults?: OAuthProviderRegistrationDefaults;
+}
+
+export interface IntegrationCatalogEntry {
+  id: string;
+  kind: IntegrationProvider;
+  name: string;
+  description: string;
+  categories?: string[];
+  appUrl?: string;
+  docsUrl?: string;
+  notes?: string;
+  iconBg?: string;
+  iconColor?: string;
+  keywords?: string[];
+  popularityRank?: number;
+  runtimeAvailability?: "all" | "local";
+  catalogStatus?: "oauth_ready" | "manual_token" | "planned";
+  managedConnectorSlug?: string;
+  authStrategy?: IntegrationAuthStrategy;
+  installHint?: string;
+  defaultConnectionOptionId?: string;
+  connectionOptions: IntegrationConnectionOption[];
+  registrationDefaults?: OAuthProviderRegistrationDefaults;
+}
+
+export const INTEGRATION_CATALOG: IntegrationCatalogEntry[];
+export function listOAuthProviderCatalog(): OAuthProviderCatalogOption[];
+export function getOAuthProviderRegistrationDefaults(
+  slug: string,
+): OAuthProviderRegistrationDefaults | undefined;
+
+export const hubspotMcpServerUrl: string;
+export const hubspotMcpAuthorizationUrl: string;
+export const hubspotMcpTokenUrl: string;
+export const hubspotRequiredScopes: readonly string[];
+export const hubspotOptionalScopes: readonly string[];
+
+export default INTEGRATION_CATALOG;

package/integrations/index.js

@@ -0,0 +1,212 @@
+import airtable from "./catalog/airtable.json" with { type: "json" };
+import apify from "./catalog/apify.json" with { type: "json" };
+import atlassian from "./catalog/atlassian.json" with { type: "json" };
+import brave_search from "./catalog/brave-search.json" with { type: "json" };
+import browser_mcp from "./catalog/browser-mcp.json" with { type: "json" };
+import clickhouse from "./catalog/clickhouse.json" with { type: "json" };
+import cloudflare_bindings from "./catalog/cloudflare-bindings.json" with { type: "json" };
+import cloudflare_browser_rendering from "./catalog/cloudflare-browser-rendering.json" with { type: "json" };
+import cloudflare_builds from "./catalog/cloudflare-builds.json" with { type: "json" };
+import cloudflare_docs from "./catalog/cloudflare-docs.json" with { type: "json" };
+import cloudflare_observability from "./catalog/cloudflare-observability.json" with { type: "json" };
+import deepwiki from "./catalog/deepwiki.json" with { type: "json" };
+import elevenlabs from "./catalog/elevenlabs.json" with { type: "json" };
+import everything from "./catalog/everything.json" with { type: "json" };
+import exa from "./catalog/exa.json" with { type: "json" };
+import fetch from "./catalog/fetch.json" with { type: "json" };
+import figma from "./catalog/figma.json" with { type: "json" };
+import filesystem from "./catalog/filesystem.json" with { type: "json" };
+import firecrawl from "./catalog/firecrawl.json" with { type: "json" };
+import git from "./catalog/git.json" with { type: "json" };
+import github from "./catalog/github.json" with { type: "json" };
+import huggingface from "./catalog/huggingface.json" with { type: "json" };
+import kagi from "./catalog/kagi.json" with { type: "json" };
+import linear from "./catalog/linear.json" with { type: "json" };
+import memory from "./catalog/memory.json" with { type: "json" };
+import mongodb from "./catalog/mongodb.json" with { type: "json" };
+import neon from "./catalog/neon.json" with { type: "json" };
+import notion from "./catalog/notion.json" with { type: "json" };
+import obsidian from "./catalog/obsidian.json" with { type: "json" };
+import paypal from "./catalog/paypal.json" with { type: "json" };
+import playwright from "./catalog/playwright.json" with { type: "json" };
+import redis from "./catalog/redis.json" with { type: "json" };
+import resend from "./catalog/resend.json" with { type: "json" };
+import sentry from "./catalog/sentry.json" with { type: "json" };
+import sequential_thinking from "./catalog/sequential-thinking.json" with { type: "json" };
+import slack from "./catalog/slack.json" with { type: "json" };
+import stripe from "./catalog/stripe.json" with { type: "json" };
+import supabase from "./catalog/supabase.json" with { type: "json" };
+import tavily from "./catalog/tavily.json" with { type: "json" };
+import time from "./catalog/time.json" with { type: "json" };
+import { listOAuthProviderCatalog } from "./oauth-provider-catalog.js";
+export { listOAuthProviderCatalog } from "./oauth-provider-catalog.js";
+export {
+  getOAuthProviderRegistrationDefaults,
+  hubspotMcpAuthorizationUrl,
+  hubspotMcpServerUrl,
+  hubspotMcpTokenUrl,
+  hubspotOptionalScopes,
+  hubspotRequiredScopes,
+} from "./oauth-provider-registration-defaults.js";
+
+const DIRECT_INTEGRATIONS = [
+  airtable,
+  apify,
+  atlassian,
+  brave_search,
+  browser_mcp,
+  clickhouse,
+  cloudflare_bindings,
+  cloudflare_browser_rendering,
+  cloudflare_builds,
+  cloudflare_docs,
+  cloudflare_observability,
+  deepwiki,
+  elevenlabs,
+  everything,
+  exa,
+  fetch,
+  figma,
+  filesystem,
+  firecrawl,
+  git,
+  github,
+  huggingface,
+  kagi,
+  linear,
+  memory,
+  mongodb,
+  neon,
+  notion,
+  obsidian,
+  paypal,
+  playwright,
+  redis,
+  resend,
+  sentry,
+  sequential_thinking,
+  slack,
+  stripe,
+  supabase,
+  tavily,
+  time,
+];
+
+const optionIdForDefaults = (defaults) => {
+  const strategy = defaults?.authStrategy ?? (defaults?.authorizationUrl || defaults?.tokenUrl ? "oauth2" : "oauth2");
+  if (strategy === "oauth2") return "oauth";
+  if (strategy === "none") return "none";
+  return "api";
+};
+
+const providerConnectionOption = (provider) => {
+  const defaults = provider.registrationDefaults;
+  if (!defaults) return null;
+  const option = {
+    id: optionIdForDefaults(defaults),
+    provider: defaults.provider ?? (defaults.serverUrl ? "mcp" : "http"),
+    auth: {
+      strategy: defaults.authStrategy ?? provider.authStrategy ?? "oauth2",
+      authModes: defaults.authModes,
+      credentialLabel: defaults.credentialLabel,
+      credentialPlaceholder: defaults.credentialPlaceholder,
+      credentialHelp: defaults.credentialHelp,
+      apiKeyHeaderName: defaults.apiKeyHeaderName,
+      oauth: defaults.authorizationUrl || defaults.tokenUrl ? {
+        authorizationUrl: defaults.authorizationUrl,
+        tokenUrl: defaults.tokenUrl,
+        scopes: defaults.scopes ?? [],
+        optionalScopes: defaults.optionalScopes,
+        toolScopes: defaults.toolScopes,
+        scopeSeparator: defaults.scopeSeparator,
+        pkce: defaults.pkce,
+        clientAuthentication: defaults.clientAuthentication,
+        registrationUrl: defaults.registrationUrl,
+        additionalAuthorizationParams: defaults.additionalAuthorizationParams,
+        additionalTokenParams: defaults.additionalTokenParams,
+      } : undefined,
+    },
+  };
+
+  if (option.provider === "mcp") {
+    option.transport = { kind: "shttp", url: defaults.serverUrl };
+  } else {
+    option.http = {
+      apiBaseUrl: defaults.apiBaseUrl,
+      openApiUrl: defaults.openApiUrl,
+      defaultTool: defaults.toolName ? {
+        name: defaults.toolName,
+        description: defaults.toolDescription,
+        method: defaults.requestMethod,
+        path: defaults.requestPath,
+        scopes: defaults.toolScopes,
+      } : undefined,
+    };
+  }
+
+  return option;
+};
+
+const providerIntegration = (provider) => {
+  const option = providerConnectionOption(provider);
+  return {
+    id: provider.slug,
+    kind: option?.provider ?? "http",
+    name: provider.name,
+    description: provider.description,
+    categories: provider.categories,
+    appUrl: provider.appUrl,
+    docsUrl: provider.docsUrl,
+    notes: provider.notes,
+    catalogStatus: provider.availability,
+    managedConnectorSlug: provider.managedConnectorSlug,
+    authStrategy: provider.authStrategy,
+    popularityRank: provider.popularityRank,
+    registrationDefaults: provider.registrationDefaults,
+    ...(option ? { defaultConnectionOptionId: option.id, connectionOptions: [option] } : { connectionOptions: [] }),
+  };
+};
+
+const mergeOptions = (left = [], right = []) => {
+  const options = new Map();
+  for (const option of left) options.set(option.id, option);
+  for (const option of right) {
+    if (!options.has(option.id)) options.set(option.id, option);
+  }
+  return [...options.values()];
+};
+
+const mergeIntegration = (base, override) => {
+  const connectionOptions = mergeOptions(base.connectionOptions, override.connectionOptions);
+  return {
+    ...base,
+    ...override,
+    catalogStatus: base.catalogStatus ?? override.catalogStatus,
+    managedConnectorSlug: base.managedConnectorSlug ?? override.managedConnectorSlug,
+    authStrategy: base.authStrategy ?? override.authStrategy,
+    registrationDefaults: base.registrationDefaults ?? override.registrationDefaults,
+    connectionOptions,
+    defaultConnectionOptionId:
+      base.defaultConnectionOptionId ?? override.defaultConnectionOptionId ?? connectionOptions[0]?.id,
+  };
+};
+
+const entriesById = new Map();
+for (const provider of listOAuthProviderCatalog().map(providerIntegration)) {
+  entriesById.set(provider.id, provider);
+}
+for (const direct of DIRECT_INTEGRATIONS) {
+  entriesById.set(
+    direct.id,
+    entriesById.has(direct.id)
+      ? mergeIntegration(entriesById.get(direct.id), direct)
+      : direct,
+  );
+}
+
+export const INTEGRATION_CATALOG = [...entriesById.values()].sort((a, b) => {
+  const rankDelta = (b.popularityRank ?? 0) - (a.popularityRank ?? 0);
+  return rankDelta || a.name.localeCompare(b.name);
+});
+
+export default INTEGRATION_CATALOG;

package/integrations/logos.d.ts

@@ -0,0 +1,5 @@
+import type { ReactNode } from "react";
+
+export const INTEGRATION_FALLBACK_LOGO: ReactNode;
+export const INTEGRATION_LOGOS: Record<string, ReactNode>;
+export const INTEGRATION_LOGO_IDS: Set<string>;

package/integrations/logos.js

@@ -0,0 +1,94 @@
+import { createElement } from "react";
+import {
+  BookOpen,
+  Bot,
+  Brain,
+  Clock,
+  Database,
+  Flame,
+  Folder,
+  GitBranch,
+  Globe,
+  ListTree,
+  MousePointerClick,
+  Search,
+  Sparkles,
+  Telescope,
+  TestTube,
+} from "lucide-react";
+import {
+  SiAirtable,
+  SiAtlassian,
+  SiBrave,
+  SiClickhouse,
+  SiCloudflare,
+  SiElevenlabs,
+  SiFigma,
+  SiGithub,
+  SiHuggingface,
+  SiKagi,
+  SiLinear,
+  SiMongodb,
+  SiNotion,
+  SiObsidian,
+  SiPaypal,
+  SiRedis,
+  SiResend,
+  SiSentry,
+  SiSlack,
+  SiStripe,
+  SiSupabase,
+} from "react-icons/si";
+
+const LOGO = "h-5 w-5";
+
+const simpleIcon = (Icon) => createElement(Icon, { className: LOGO });
+const lucideIcon = (Icon) =>
+  createElement(Icon, { className: LOGO, strokeWidth: 2.25 });
+
+export const INTEGRATION_FALLBACK_LOGO = lucideIcon(Bot);
+
+export const INTEGRATION_LOGOS = {
+  github: simpleIcon(SiGithub),
+  slack: simpleIcon(SiSlack),
+  tavily: createElement(Search, { className: LOGO, strokeWidth: 2.5 }),
+  linear: simpleIcon(SiLinear),
+  notion: simpleIcon(SiNotion),
+  atlassian: simpleIcon(SiAtlassian),
+  sentry: simpleIcon(SiSentry),
+  stripe: simpleIcon(SiStripe),
+  paypal: simpleIcon(SiPaypal),
+  "cloudflare-docs": simpleIcon(SiCloudflare),
+  "cloudflare-bindings": simpleIcon(SiCloudflare),
+  "cloudflare-observability": simpleIcon(SiCloudflare),
+  huggingface: simpleIcon(SiHuggingface),
+  deepwiki: simpleIcon(BookOpen),
+  git: lucideIcon(GitBranch),
+  "brave-search": simpleIcon(SiBrave),
+  exa: lucideIcon(Telescope),
+  firecrawl: lucideIcon(Flame),
+  apify: lucideIcon(Bot),
+  fetch: lucideIcon(Globe),
+  "browser-mcp": lucideIcon(MousePointerClick),
+  playwright: lucideIcon(TestTube),
+  supabase: simpleIcon(SiSupabase),
+  neon: lucideIcon(Database),
+  mongodb: simpleIcon(SiMongodb),
+  redis: simpleIcon(SiRedis),
+  filesystem: lucideIcon(Folder),
+  memory: lucideIcon(Brain),
+  "sequential-thinking": lucideIcon(ListTree),
+  time: lucideIcon(Clock),
+  everything: lucideIcon(Sparkles),
+  figma: simpleIcon(SiFigma),
+  airtable: simpleIcon(SiAirtable),
+  obsidian: simpleIcon(SiObsidian),
+  elevenlabs: simpleIcon(SiElevenlabs),
+  resend: simpleIcon(SiResend),
+  "cloudflare-builds": simpleIcon(SiCloudflare),
+  "cloudflare-browser-rendering": simpleIcon(SiCloudflare),
+  kagi: simpleIcon(SiKagi),
+  clickhouse: simpleIcon(SiClickhouse),
+};
+
+export const INTEGRATION_LOGO_IDS = new Set(Object.keys(INTEGRATION_LOGOS));