@openhands/extensions 0.5.0 → 0.6.0

package/integrations/index.d.ts

@@ -88,52 +88,9 @@ export interface IntegrationConnectionOption {
   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[];
@@ -142,28 +99,35 @@ export interface IntegrationCatalogEntry {
   notes?: string;
   iconBg?: string;
   iconColor?: string;
+  logoUrl?: 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[];
+/**
+ * Filter for {@link listIntegrationCatalog}. Each dimension is tri-state:
+ * `true` keeps only entries that support that connector type, `false` keeps
+ * only entries that do not, and `undefined` leaves that dimension unfiltered.
+ */
+export interface IntegrationCatalogFilter {
+  /** Filter on whether the entry exposes at least one `mcp` connector. */
+  mcp?: boolean;
+  /** Filter on whether the entry exposes at least one `oauth2` connector. */
+  oauth?: boolean;
+}
 
+export const INTEGRATION_CATALOG: IntegrationCatalogEntry[];
+/**
+ * Return the full integration catalog, optionally filtered by connector type.
+ * Reads the generated static import index over `integrations/catalog/<id>.json`.
+ * Returns the cached array; callers must treat it as read-only.
+ */
+export function listIntegrationCatalog(
+  filter?: IntegrationCatalogFilter,
+): IntegrationCatalogEntry[];
+export function getIntegrationCatalogEntry(
+  id: string,
+): IntegrationCatalogEntry | undefined;
 export default INTEGRATION_CATALOG;

package/integrations/index.js

@@ -1,212 +1,34 @@
-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,
-  };
+/**
+ * Runtime integration catalog.
+ *
+ * The source of truth is the hand-authored `integrations/catalog/<id>.json`
+ * directory. `catalog-index.js` is generated from that directory so the JS
+ * package can statically import each JSON file without an aggregate JSON asset.
+ */
+import { INTEGRATION_CATALOG_ENTRIES } from "./catalog-index.js";
+
+const INTEGRATIONS = INTEGRATION_CATALOG_ENTRIES;
+const INTEGRATION_BY_ID = new Map(INTEGRATIONS.map((entry) => [entry.id, entry]));
+
+const entrySupportsMcp = (entry) =>
+  entry.connectionOptions.some((option) => option.provider === "mcp");
+
+const entrySupportsOauth = (entry) =>
+  entry.connectionOptions.some((option) => option.auth?.strategy === "oauth2");
+
+export const listIntegrationCatalog = (filter) => {
+  if (!filter) return INTEGRATIONS;
+  const { mcp, oauth } = filter;
+  if (mcp === undefined && oauth === undefined) return INTEGRATIONS;
+  return INTEGRATIONS.filter((entry) => {
+    const mcpOk = mcp === undefined || entrySupportsMcp(entry) === mcp;
+    const oauthOk = oauth === undefined || entrySupportsOauth(entry) === oauth;
+    return mcpOk && oauthOk;
+  });
 };
 
-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 getIntegrationCatalogEntry = (id) => INTEGRATION_BY_ID.get(id);
 
-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 const INTEGRATION_CATALOG = INTEGRATIONS;
 
 export default INTEGRATION_CATALOG;

package/marketplaces/openhands-extensions.json

@@ -88,6 +88,19 @@
         "openhands"
       ]
     },
+    {
+      "name": "agent-canvas-environment",
+      "source": "./skills/agent-canvas-environment",
+      "description": "Work effectively inside a local Agent Canvas environment, including local agent-server auth, safe workspace hygiene, and local conversation delegation.",
+      "category": "development",
+      "keywords": [
+        "agent-canvas",
+        "openhands",
+        "local",
+        "conversation",
+        "delegation"
+      ]
+    },
     {
       "name": "openhands-sdk",
       "source": "./skills/openhands-sdk",
@@ -404,7 +417,7 @@
     {
       "name": "openhands-api",
       "source": "./skills/openhands-api",
-      "description": "Use the OpenHands Cloud REST API (V1) to create and manage app conversations, including multi-conversation delegation workflows, and to access sandbox agent-server endpoints. Includes minimal Python and TypeScript clients under scripts/.",
+      "description": "Use the OpenHands Cloud REST API (V1) and agent-server APIs to create and manage Cloud or local backend conversations, including multi-conversation delegation workflows. Includes minimal Python and TypeScript clients under scripts/.",
       "category": "development",
       "keywords": [
         "openhands",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openhands/extensions",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Public OpenHands extension catalogs for skills, plugins, integrations, and automation templates.",
   "license": "MIT",
   "type": "module",
@@ -9,7 +9,9 @@
     "url": "https://github.com/OpenHands/extensions"
   },
   "scripts": {
-    "build:skills": "node scripts/build-skills-catalog.mjs"
+    "build:skills": "node scripts/build-skills-catalog.mjs",
+    "build:integrations": "node scripts/build-integration-catalog.mjs",
+    "build": "npm run build:skills && npm run build:integrations"
   },
   "engines": {
     "node": ">=18.20.0"
@@ -39,11 +41,6 @@
       "import": "./integrations/index.js",
       "default": "./integrations/index.js"
     },
-    "./integrations/logos": {
-      "types": "./integrations/logos.d.ts",
-      "import": "./integrations/logos.js",
-      "default": "./integrations/logos.js"
-    },
     "./integrations/catalog/*.json": "./integrations/catalog/*.json",
     "./skills": {
       "types": "./skills/index.d.ts",

package/plugins/cobol-modernization/README.md

@@ -36,11 +36,11 @@ plugins/cobol-modernization/
 └── skills/                                # Workflow phase skills
     ├── build-setup/                       # Phase 1: Build environment
     │   └── SKILL.md
-    ├── cobol-modernization-overview/      # Plugin overview
+    ├── cobol-modernization/               # Plugin overview
     │   └── SKILL.md
     ├── mainframe-planning/                # Phase 2: Transformation planning
     │   └── SKILL.md
-    ├── mainfraime-removal/                # Phase 3: Mainframe dependency removal
+    ├── mainframe-removal/                 # Phase 3: Mainframe dependency removal
     │   ├── SKILL.md
     │   └── references/
     │       └── cics-transformation-examples.md
@@ -139,7 +139,7 @@ You can also run individual phases by using the specific skill definitions:
 
 - See [skills/build-setup/SKILL.md](skills/build-setup/SKILL.md) for build setup only
 - See [skills/mainframe-planning/SKILL.md](skills/mainframe-planning/SKILL.md) for planning
-- See [skills/mainfraime-removal/SKILL.md](skills/mainfraime-removal/SKILL.md) for mainframe removal
+- See [skills/mainframe-removal/SKILL.md](skills/mainframe-removal/SKILL.md) for mainframe removal
 - See [skills/to-java-migration/SKILL.md](skills/to-java-migration/SKILL.md) for Java translation
 
 ## Troubleshooting

package/plugins/cobol-modernization/skills/{cobol-modernization-overview → cobol-modernization}/SKILL.md

@@ -67,7 +67,7 @@ Creates a transformation guide without modifying code:
 
 ### Phase 3: Mainframe Removal
 
-See [../mainfraime-removal/SKILL.md](../mainfraime-removal/SKILL.md)
+See [../mainframe-removal/SKILL.md](../mainframe-removal/SKILL.md)
 
 Applies the transformation guide:
 - Replaces EXEC CICS commands with file I/O

package/plugins/magic-test/skills/magic-word/SKILL.md

@@ -1,4 +1,5 @@
 ---
+name: magic-word
 description: A test skill that responds to the magic word "alakazam" with a specific phrase
 triggers:
   - alakazam

package/plugins/migration-scoring/README.md

@@ -34,7 +34,7 @@ uv run python -m lc_sdk_examples.migration_scoring \
 plugins/migration-scoring/
 ├── README.md                              # This file
 └── skills/                                # Workflow phase skills
-    ├── migration-scoring-overview/        # Plugin overview
+    ├── migration-scoring/                 # Plugin overview
     │   └── SKILL.md
     ├── migration-mapping/                 # Phase 1: Source-to-target mapping
     │   └── SKILL.md

package/pyproject.toml

@@ -1,12 +1,26 @@
 [project]
-name = "extensions"
-version = "0.5.0"
-description = "OpenHands extensions, plugins, and skills"
+name = "openhands-extensions"
+version = "0.6.0"
+description = "OpenHands extensions, plugins, and skills (Python bindings for the integration catalog)"
 requires-python = ">=3.12"
 
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["python/openhands_extensions"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"integrations/catalog" = "openhands_extensions/catalog"
+
 [dependency-groups]
 test = [
     "pytest>=8.0",
     "requests>=2.31",
     "openhands-sdk>=0.3",
 ]
+
+[tool.pytest.ini_options]
+pythonpath = ["python"]
+testpaths = ["tests"]

package/python/openhands_extensions/__init__.py

@@ -0,0 +1,24 @@
+"""Python bindings for the OpenHands extensions catalogs.
+
+Mirrors the JavaScript package (``@openhands/extensions``): both read the same
+hand-authored ``integrations/catalog/<id>.json`` files. The JavaScript package
+uses a generated static import index; the Python package loads the packaged
+individual JSON files directly. See ``integrations.py`` for the catalog API,
+including filtering by connector type (mcp / oauth).
+"""
+
+from __future__ import annotations
+
+from ._version import __version__
+from .integrations import (
+    INTEGRATION_CATALOG_SNAPSHOT,
+    get_integration_catalog_entry,
+    list_integration_catalog,
+)
+
+__all__ = [
+    "INTEGRATION_CATALOG_SNAPSHOT",
+    "__version__",
+    "get_integration_catalog_entry",
+    "list_integration_catalog",
+]

package/python/openhands_extensions/_version.py

@@ -0,0 +1,24 @@
+"""Package version, derived from installed package metadata.
+
+The single source of truth is ``pyproject.toml``'s ``[project].version``
+(which ``release-please`` bumps together with ``package.json`` via
+``release-please-config.json`` -> ``extra-files``). At runtime we read the
+installed distribution metadata via ``importlib.metadata`` so there is no
+second hand-maintained version string. ``_FALLBACK_VERSION`` is only used
+when the package is imported without being installed (e.g. straight off a
+source checkout with no build), and ``tests/test_version_alignment.py``
+asserts it stays in lock-step with ``pyproject.toml`` / ``package.json``.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+#: Fallback used only when the package is not installed (no dist metadata).
+#: Kept in lock-step with pyproject.toml/package.json by the version test.
+_FALLBACK_VERSION = "0.6.0"
+
+try:
+    __version__: str = version("openhands-extensions")
+except PackageNotFoundError:  # not installed (e.g. raw source checkout)
+    __version__ = _FALLBACK_VERSION

package/python/openhands_extensions/integrations.py

@@ -0,0 +1,92 @@
+"""Python bindings for the OpenHands extensions integration catalog.
+
+The source of truth is the hand-authored ``integrations/catalog/<id>.json``
+directory. Wheels include those individual JSON files directly; no aggregate
+catalog JSON is authored or packaged.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+from functools import lru_cache
+from importlib import resources
+from pathlib import Path
+from typing import Any, Iterable
+
+__all__ = [
+    "INTEGRATION_CATALOG_SNAPSHOT",
+    "get_integration_catalog_entry",
+    "list_integration_catalog",
+]
+
+
+def _repo_catalog_dir() -> Path:
+    return Path(__file__).resolve().parents[2] / "integrations" / "catalog"
+
+
+def _catalog_files() -> Iterable[Any]:
+    packaged = resources.files(__package__).joinpath("catalog")
+    if packaged.is_dir():
+        return sorted(
+            (path for path in packaged.iterdir() if path.name.endswith(".json")),
+            key=lambda path: path.name,
+        )
+
+    repo_catalog = _repo_catalog_dir()
+    return sorted(repo_catalog.glob("*.json"), key=lambda path: path.name)
+
+
+def _read_json(path: Any) -> dict[str, Any]:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+@lru_cache(maxsize=1)
+def _integrations() -> tuple[dict[str, Any], ...]:
+    entries = [_read_json(path) for path in _catalog_files()]
+    entries.sort(
+        key=lambda entry: (-(entry.get("popularityRank") if entry.get("popularityRank") is not None else -1), entry["id"]),
+    )
+    return tuple(entries)
+
+
+@lru_cache(maxsize=1)
+def _integration_by_id() -> dict[str, dict[str, Any]]:
+    return {entry["id"]: entry for entry in _integrations()}
+
+
+def _entry_supports_mcp(entry: dict[str, Any]) -> bool:
+    return any(option.get("provider") == "mcp" for option in entry.get("connectionOptions", []))
+
+
+def _entry_supports_oauth(entry: dict[str, Any]) -> bool:
+    return any(
+        option.get("auth", {}).get("strategy") == "oauth2"
+        for option in entry.get("connectionOptions", [])
+    )
+
+
+def list_integration_catalog(
+    mcp: bool | None = None,
+    oauth: bool | None = None,
+) -> list[dict[str, Any]]:
+    """Return the integration catalog, optionally filtered by connector type."""
+    result = []
+    for entry in _integrations():
+        if mcp is not None and _entry_supports_mcp(entry) != mcp:
+            continue
+        if oauth is not None and _entry_supports_oauth(entry) != oauth:
+            continue
+        result.append(copy.deepcopy(entry))
+    return result
+
+
+def get_integration_catalog_entry(id: str) -> dict[str, Any] | None:
+    """Return one integration catalog entry by id, or ``None``."""
+    entry = _integration_by_id().get(id)
+    return copy.deepcopy(entry) if entry is not None else None
+
+
+INTEGRATION_CATALOG_SNAPSHOT: dict[str, Any] = {
+    "integrations": copy.deepcopy(list(_integrations()))
+}

package/release-please-config.json

@@ -9,7 +9,8 @@
       "include-component-in-tag": false,
       "skip-changelog": true,
       "extra-files": [
-        { "type": "toml", "path": "pyproject.toml", "jsonpath": "$.project.version" }
+        { "type": "toml", "path": "pyproject.toml", "jsonpath": "$.project.version" },
+        "python/openhands_extensions/_version.py"
       ]
     }
   }