@commandable/integration-data 0.0.1

package/integrations/google-slides/credentials.json

@@ -0,0 +1,36 @@
+{
+  "schema": {
+    "type": "object",
+    "properties": {
+      "token": {
+        "type": "string",
+        "title": "OAuth Access Token (optional)",
+        "description": "Google OAuth access token to use as a Bearer token (typically short-lived)."
+      },
+      "serviceAccountJson": {
+        "type": "string",
+        "title": "Service Account JSON (recommended)",
+        "description": "Full service account key JSON (contents of the downloaded JSON file)."
+      },
+      "subject": {
+        "type": "string",
+        "title": "Subject / impersonated user (optional)",
+        "description": "Optional user email to impersonate when using Google Workspace domain-wide delegation."
+      },
+      "scopes": {
+        "type": "array",
+        "title": "OAuth scopes (optional)",
+        "description": "Optional override for OAuth scopes.",
+        "items": { "type": "string" }
+      }
+    },
+    "required": [],
+    "additionalProperties": false
+  },
+  "injection": {
+    "headers": {
+      "Authorization": "Bearer {{token}}"
+    }
+  }
+}
+

package/integrations/google-slides/credentials_hint.md

@@ -0,0 +1,9 @@
+Recommended: use a Google service account.
+
+- Create a service account in Google Cloud
+- Download a JSON key
+- Paste the JSON into `serviceAccountJson` (or use `env:GOOGLE_SERVICE_ACCOUNT_JSON`)
+- Share your test presentation with the service account `client_email`
+
+You can also paste a short-lived OAuth access token into `token`, but it will expire.
+

package/integrations/google-slides/handlers/append_text_to_title_of_first_slide.js

@@ -0,0 +1,17 @@
+async (input) => {
+  const { presentationId, text, slideIndex = 0 } = input
+  const presRes = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}`)
+  const pres = await presRes.json()
+  const slide = (pres?.slides || [])[slideIndex]
+  if (!slide)
+    return { presentationId, applied: false, replies: [] }
+  const titleShape = (slide.pageElements || []).find(el => el.shape?.placeholder?.type === 'TITLE')
+  if (!titleShape?.objectId)
+    return { presentationId, applied: false, replies: [] }
+  const res = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}:batchUpdate`, {
+    method: 'POST',
+    body: { requests: [{ insertText: { objectId: titleShape.objectId, insertionIndex: -1, text } }] },
+  })
+  const out = await res.json()
+  return out?.presentationId ? { ...out, applied: true } : { presentationId, applied: true, replies: out?.replies || [] }
+}

package/integrations/google-slides/handlers/batch_update.js

@@ -0,0 +1,15 @@
+async (input) => {
+  const { presentationId, requests, includePresentationInResponse, responsePageObjectIds, writeControl } = input
+  const params = new URLSearchParams()
+  if (includePresentationInResponse !== undefined)
+    params.set('includePresentationInResponse', String(includePresentationInResponse))
+  if (Array.isArray(responsePageObjectIds))
+    responsePageObjectIds.forEach(id => params.append('responsePageObjectIds', String(id)))
+  const qs = params.toString()
+  const path = `/presentations/${encodeURIComponent(presentationId)}:batchUpdate${qs ? `?${qs}` : ''}`
+  const body = { requests }
+  if (writeControl)
+    body.writeControl = writeControl
+  const res = await integration.fetch(path, { method: 'POST', body })
+  return await res.json()
+}

package/integrations/google-slides/handlers/create_presentation.js

@@ -0,0 +1,8 @@
+async (input) => {
+  const body = {}
+  if (input && typeof input.title === 'string') {
+    body.title = input.title
+  }
+  const res = await integration.fetch('/presentations', { method: 'POST', body })
+  return await res.json()
+}

package/integrations/google-slides/handlers/create_slide_after_first_match.js

@@ -0,0 +1,20 @@
+async (input) => {
+  const { presentationId, findText, layout = 'BLANK' } = input
+  const presRes = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}`)
+  const pres = await presRes.json()
+  let targetSlideId = null
+  for (const slide of (pres?.slides || [])) {
+    const text = JSON.stringify(slide)
+    if (text && text.includes(findText)) { targetSlideId = slide.objectId; break }
+  }
+  if (!targetSlideId)
+    return { presentationId, applied: false, replies: [] }
+  const newSlideId = `slide_${Date.now()}`
+  const currentIndex = (pres?.slides || []).findIndex(s => s.objectId === targetSlideId)
+  const requests = [
+    { createSlide: { objectId: newSlideId, insertionIndex: currentIndex >= 0 ? currentIndex + 1 : (pres?.slides?.length || 0), slideLayoutReference: { predefinedLayout: layout } } },
+  ]
+  const res = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}:batchUpdate`, { method: 'POST', body: { requests } })
+  const out = await res.json()
+  return out?.presentationId ? { ...out, applied: true } : { presentationId, applied: true, replies: out?.replies || [] }
+}

package/integrations/google-slides/handlers/get_page_thumbnail.js

@@ -0,0 +1,12 @@
+async (input) => {
+  const { presentationId, pageObjectId } = input
+  const params = new URLSearchParams()
+  if (input['thumbnailProperties.thumbnailSize'])
+    params.set('thumbnailProperties.thumbnailSize', String(input['thumbnailProperties.thumbnailSize']))
+  if (input['thumbnailProperties.mimeType'])
+    params.set('thumbnailProperties.mimeType', String(input['thumbnailProperties.mimeType']))
+  const qs = params.toString()
+  const path = `/presentations/${encodeURIComponent(presentationId)}/pages/${encodeURIComponent(pageObjectId)}/thumbnail${qs ? `?${qs}` : ''}`
+  const res = await integration.fetch(path)
+  return await res.json()
+}

package/integrations/google-slides/handlers/get_presentation.js

@@ -0,0 +1,6 @@
+async (input) => {
+  const { presentationId } = input
+  const path = `/presentations/${encodeURIComponent(presentationId)}`
+  const res = await integration.fetch(path)
+  return await res.json()
+}

package/integrations/google-slides/handlers/insert_image_after_first_match.js

@@ -0,0 +1,19 @@
+async (input) => {
+  const { presentationId, findText, uri, width = 2000000, height = 2000000 } = input
+  const presRes = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}`)
+  const pres = await presRes.json()
+  let targetSlideId = null
+  for (const slide of (pres?.slides || [])) {
+    const text = JSON.stringify(slide)
+    if (text && text.includes(findText)) { targetSlideId = slide.objectId; break }
+  }
+  if (!targetSlideId)
+    return { presentationId, applied: false, replies: [] }
+  const elementId = `image_${Date.now()}`
+  const requests = [
+    { createImage: { objectId: elementId, url: uri, elementProperties: { pageObjectId: targetSlideId, size: { width: { magnitude: width, unit: 'EMU' }, height: { magnitude: height, unit: 'EMU' } }, transform: { scaleX: 1, scaleY: 1, translateX: 1000000, translateY: 1000000, unit: 'EMU' } } } },
+  ]
+  const res = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}:batchUpdate`, { method: 'POST', body: { requests } })
+  const out = await res.json()
+  return out?.presentationId ? { ...out, applied: true } : { presentationId, applied: true, replies: out?.replies || [] }
+}

package/integrations/google-slides/handlers/insert_shape_after_first_match.js

@@ -0,0 +1,21 @@
+async (input) => {
+  const { presentationId, findText, shapeType = 'RECTANGLE', width = 2000000, height = 1000000 } = input
+  const presRes = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}`)
+  const pres = await presRes.json()
+  // Find slide with first text match
+  let targetSlideId = null
+  for (const slide of (pres?.slides || [])) {
+    const text = JSON.stringify(slide)
+    if (text && text.includes(findText)) { targetSlideId = slide.objectId; break }
+  }
+  if (!targetSlideId)
+    return { presentationId, applied: false, replies: [] }
+  // Insert a shape at a default position near center
+  const elementId = `shape_${Date.now()}`
+  const requests = [
+    { createShape: { objectId: elementId, shapeType, elementProperties: { pageObjectId: targetSlideId, size: { width: { magnitude: width, unit: 'EMU' }, height: { magnitude: height, unit: 'EMU' } }, transform: { scaleX: 1, scaleY: 1, translateX: 1000000, translateY: 1000000, unit: 'EMU' } } } },
+  ]
+  const res = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}:batchUpdate`, { method: 'POST', body: { requests } })
+  const out = await res.json()
+  return out?.presentationId ? { ...out, applied: true } : { presentationId, applied: true, replies: out?.replies || [] }
+}

package/integrations/google-slides/handlers/replace_text_first_match.js

@@ -0,0 +1,9 @@
+async (input) => {
+  const { presentationId, findText, replaceText, matchCase } = input
+  const res = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}:batchUpdate`, {
+    method: 'POST',
+    body: { requests: [{ replaceAllText: { containsText: { text: findText, matchCase: Boolean(matchCase) }, replaceText } }] },
+  })
+  const out = await res.json()
+  return out?.presentationId ? { ...out, applied: true } : { presentationId, applied: true, replies: out?.replies || [] }
+}

package/integrations/google-slides/handlers/set_background_color_for_slide_index.js

@@ -0,0 +1,15 @@
+async (input) => {
+  const { presentationId, slideIndex, rgbColor } = input
+  const presRes = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}`)
+  const pres = await presRes.json()
+  const slide = (pres?.slides || [])[slideIndex]
+  if (!slide?.objectId)
+    return { presentationId, applied: false, replies: [] }
+  const color = { color: { rgbColor } }
+  const res = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}:batchUpdate`, {
+    method: 'POST',
+    body: { requests: [{ updatePageProperties: { objectId: slide.objectId, pageProperties: { pageBackgroundFill: { solidFill: color } }, fields: 'pageBackgroundFill.solidFill.color' } }] },
+  })
+  const out = await res.json()
+  return out?.presentationId ? { ...out, applied: true } : { presentationId, applied: true, replies: out?.replies || [] }
+}

package/integrations/google-slides/handlers/style_text_first_match.js

@@ -0,0 +1,48 @@
+async (input) => {
+  const { presentationId, findText, textStyle, fields } = input
+  // Replace first match with a marker to derive objectId/range
+  const marker = `__CMD_MARK_${Date.now()}__`
+  const rep = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}:batchUpdate`, {
+    method: 'POST',
+    body: { requests: [{ replaceAllText: { containsText: { text: findText, matchCase: false }, replaceText: marker } }] },
+  })
+  await rep.json()
+  // Scan pages for marker and apply style to that range on the text element
+  const presRes = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}`)
+  const pres = await presRes.json()
+  let targetObjectId = null
+  let startIndex = -1
+  let endIndex = -1
+  for (const slide of (pres?.slides || [])) {
+    for (const el of (slide.pageElements || [])) {
+      const text = el.shape?.text
+      if (!text)
+        continue
+      for (const pe of (text.textElements || [])) {
+        const t = pe.textRun?.content
+        if (!t)
+          continue
+        const idx = t.indexOf(marker)
+        if (idx >= 0) {
+          targetObjectId = el.objectId
+          startIndex = (pe.startIndex || 0) + idx
+          endIndex = startIndex + marker.length
+          break
+        }
+      }
+      if (targetObjectId)
+        break
+    }
+    if (targetObjectId)
+      break
+  }
+  if (!targetObjectId)
+    return { presentationId, applied: false, replies: [] }
+  const requests = [
+    { updateTextStyle: { objectId: targetObjectId, style: textStyle, textRange: { type: 'FIXED_RANGE', startIndex, endIndex }, fields: fields || Object.keys(textStyle || {}).join(',') } },
+    { replaceAllText: { containsText: { text: marker, matchCase: true }, replaceText: findText } },
+  ]
+  const res = await integration.fetch(`/presentations/${encodeURIComponent(presentationId)}:batchUpdate`, { method: 'POST', body: { requests } })
+  const out = await res.json()
+  return out?.presentationId ? { ...out, applied: true } : { presentationId, applied: true, replies: out?.replies || [] }
+}

package/integrations/google-slides/manifest.json

@@ -0,0 +1,41 @@
+{
+  "name": "google-slides",
+  "version": "0.1.0",
+  "tools": [
+    {
+      "name": "get_presentation",
+      "description": "Retrieve presentation metadata, including slides/pages and elements.",
+      "inputSchema": "schemas/get_presentation.json",
+      "handler": "handlers/get_presentation.js",
+      "scope": "read"
+    },
+    {
+      "name": "get_page_thumbnail",
+      "description": "Get a thumbnail image for a page (slide) in a presentation.",
+      "inputSchema": "schemas/get_page_thumbnail.json",
+      "handler": "handlers/get_page_thumbnail.js",
+      "scope": "read"
+    },
+    {
+      "name": "create_presentation",
+      "description": "Create a new presentation with optional initial title.",
+      "inputSchema": "schemas/create_presentation.json",
+      "handler": "handlers/create_presentation.js",
+      "scope": "write"
+    },
+    {
+      "name": "batch_update",
+      "description": "Send a batchUpdate request to modify presentation structure and content.",
+      "inputSchema": "schemas/batch_update.json",
+      "handler": "handlers/batch_update.js",
+      "scope": "write"
+    },
+    { "name": "append_text_to_title_of_slide_index", "description": "Append text to the title shape of the specified slide (slideIndex, default 0).", "inputSchema": "schemas/append_text_to_title_of_first_slide.json", "handler": "handlers/append_text_to_title_of_first_slide.js", "scope": "write" },
+    { "name": "replace_text_first_match", "description": "Replace text for the first match anywhere in the presentation.", "inputSchema": "schemas/replace_text_first_match.json", "handler": "handlers/replace_text_first_match.js", "scope": "write" },
+    { "name": "style_text_first_match", "description": "Apply text style to the first match of given text.", "inputSchema": "schemas/style_text_first_match.json", "handler": "handlers/style_text_first_match.js", "scope": "write" },
+    { "name": "insert_shape_after_first_match", "description": "Insert a rectangle shape near the first match of text on a slide.", "inputSchema": "schemas/insert_shape_after_first_match.json", "handler": "handlers/insert_shape_after_first_match.js", "scope": "write" },
+    { "name": "insert_image_after_first_match", "description": "Insert an image near the first match of text on a slide.", "inputSchema": "schemas/insert_image_after_first_match.json", "handler": "handlers/insert_image_after_first_match.js", "scope": "write" },
+    { "name": "create_slide_after_first_match", "description": "Create a new slide after the slide that contains the first text match.", "inputSchema": "schemas/create_slide_after_first_match.json", "handler": "handlers/create_slide_after_first_match.js", "scope": "write" },
+    { "name": "set_background_color_for_slide_index", "description": "Set background color for a slide by index.", "inputSchema": "schemas/set_background_color_for_slide_index.json", "handler": "handlers/set_background_color_for_slide_index.js", "scope": "write" }
+  ]
+}

package/integrations/google-slides/schemas/append_text_to_title_of_first_slide.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "presentationId": { "type": "string" },
+    "text": { "type": "string" },
+    "slideIndex": { "type": "number", "minimum": 0, "description": "Zero-based slide index to target (default 0)." }
+  },
+  "required": ["presentationId", "text"],
+  "additionalProperties": false
+}

package/integrations/google-slides/schemas/batch_update.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["presentationId", "requests"],
+  "properties": {
+    "presentationId": { "type": "string", "description": "ID of the presentation." },
+    "requests": { "type": "array", "items": { "type": "object" }, "description": "Array of Slides API requests." },
+    "writeControl": { "type": "object", "description": "Optional write control object." },
+    "includePresentationInResponse": { "type": "boolean" },
+    "responsePageObjectIds": { "type": "array", "items": { "type": "string" } }
+  },
+  "additionalProperties": false
+}

package/integrations/google-slides/schemas/create_presentation.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "title": { "type": "string", "description": "Optional title for the new presentation." }
+  },
+  "additionalProperties": false
+}

package/integrations/google-slides/schemas/create_slide_after_first_match.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "presentationId": { "type": "string" },
+    "findText": { "type": "string" },
+    "layout": { "type": "string", "default": "BLANK" }
+  },
+  "required": ["presentationId", "findText"],
+  "additionalProperties": false
+}

package/integrations/google-slides/schemas/get_page_thumbnail.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["presentationId", "pageObjectId"],
+  "properties": {
+    "presentationId": { "type": "string", "description": "ID of the presentation." },
+    "pageObjectId": { "type": "string", "description": "Object ID of the page (slide)." },
+    "thumbnailProperties.thumbnailSize": { "type": "string", "enum": ["THUMBNAIL_SIZE_UNSPECIFIED", "LARGE", "MEDIUM", "SMALL"], "description": "Requested size hint for the thumbnail." },
+    "thumbnailProperties.mimeType": { "type": "string", "enum": ["PNG", "JPEG"], "description": "Requested image MIME type." }
+  },
+  "additionalProperties": false
+}

package/integrations/google-slides/schemas/get_presentation.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["presentationId"],
+  "properties": {
+    "presentationId": { "type": "string", "description": "ID of the presentation." }
+  },
+  "additionalProperties": false
+}

package/integrations/google-slides/schemas/insert_image_after_first_match.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "presentationId": { "type": "string" },
+    "findText": { "type": "string" },
+    "uri": { "type": "string" },
+    "width": { "type": "number", "default": 2000000 },
+    "height": { "type": "number", "default": 2000000 }
+  },
+  "required": ["presentationId", "findText", "uri"],
+  "additionalProperties": false
+}

package/integrations/google-slides/schemas/insert_shape_after_first_match.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "presentationId": { "type": "string" },
+    "findText": { "type": "string" },
+    "shapeType": { "type": "string", "default": "RECTANGLE" },
+    "width": { "type": "number", "default": 2000000 },
+    "height": { "type": "number", "default": 1000000 }
+  },
+  "required": ["presentationId", "findText"],
+  "additionalProperties": false
+}

package/integrations/google-slides/schemas/replace_text_first_match.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "presentationId": { "type": "string" },
+    "findText": { "type": "string" },
+    "replaceText": { "type": "string" },
+    "matchCase": { "type": "boolean" }
+  },
+  "required": ["presentationId", "findText", "replaceText"],
+  "additionalProperties": false
+}

package/integrations/google-slides/schemas/set_background_color_for_slide_index.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "presentationId": { "type": "string" },
+    "slideIndex": { "type": "number", "minimum": 0 },
+    "rgbColor": { "type": "object", "properties": { "red": { "type": "number" }, "green": { "type": "number" }, "blue": { "type": "number" } }, "required": ["red", "green", "blue"] }
+  },
+  "required": ["presentationId", "slideIndex", "rgbColor"],
+  "additionalProperties": false
+}

package/integrations/google-slides/schemas/style_text_first_match.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "presentationId": { "type": "string" },
+    "findText": { "type": "string" },
+    "textStyle": { "type": "object" },
+    "fields": { "type": "string" }
+  },
+  "required": ["presentationId", "findText", "textStyle"],
+  "additionalProperties": false
+}

package/integrations/new_integration_prompt.md

@@ -0,0 +1,41 @@
+## Task
+
+Write a new integration-data folder for `<INTEGRATION_NAME>`.
+
+## Required structure
+
+Create `commandable-mcp/packages/server/integration-data/<name>/` containing:
+
+- `manifest.json`: flat `tools[]`; each tool has `name`, `description`, `inputSchema` (relative path), `handler` (relative path), `scope` (`read` | `write` | optionally `admin`)
+- `schemas/*.json`: JSON Schema for each tool input. Prefer `additionalProperties: false` for strict contracts; use `true` only for pass-through bodies (common in Google APIs). Reuse `empty.json` for no-arg tools.
+- `handlers/*.js`: async arrow functions `async (input) => { ... }` using `integration.fetch(path, init?)` for all HTTP calls. Pass `body` as a plain object (proxy will JSON-stringify). Return parsed JSON.
+- `credentials.json`: `{ schema, injection }` where `schema` is JSON Schema for secrets and `injection` is `headers` and/or `query` templates using `{{placeholder}}`
+- `credentials_hint.md`: **numbered steps** (1., 2., 3., …) telling a user exactly how to obtain/provide credentials
+- `prompt.md` (optional): extra LLM guidance only if the API has non-obvious usage patterns
+
+Also register the provider in `src/integrations/providerRegistry.ts` with its base URL and auth factory.
+
+## Tool design goals
+
+- **Default**: small, composable tools that mirror API resources.
+- **Read tools**: side-effect free (GET only).
+- **Write tools**: POST/PUT/PATCH/DELETE where appropriate.
+- **Coverage**: start with core CRUD + list/search + get-by-id; add convenience tools after.
+
+## When to go beyond REST proxying
+
+Most handlers should be thin proxies (fetch → return JSON). Only add multi-step/orchestrating handlers when the raw API is genuinely hard for an LLM to use correctly, e.g.:
+
+- multi-step workflows (GitHub tree → blob → commit → ref)
+- required transforms (e.g. base64 encoding) that the caller shouldn’t manage
+- awkward addressing that benefits from higher-level helpers (“find text then act” patterns like Docs/Slides)
+
+If an endpoint is already clean and self-contained, just proxy it.
+
+## Reference examples (follow exactly)
+
+- `github/`: simple proxies + complex orchestration (`create_commit.js`)
+- `notion/`: clean proxying + optional `prompt.md`
+- `google-calendar/`: query param building + `read`/`write`/`admin` scopes
+- `trello/`: query-param credential injection + `displayCards`
+- `google-docs/`, `google-slides/`: higher-level write helpers over batchUpdate APIs

package/integrations/notion/__tests__/get_handlers.test.ts

@@ -0,0 +1,153 @@
+import { beforeAll, describe, expect, it } from 'vitest'
+import { IntegrationProxy } from '../../../src/integrations/proxy.js'
+import { loadIntegrationTools } from '../../../src/integrations/dataLoader.js'
+
+// LIVE Notion integration tests using managed OAuth
+// Required env vars:
+// - COMMANDABLE_MANAGED_OAUTH_BASE_URL
+// - COMMANDABLE_MANAGED_OAUTH_SECRET_KEY
+// - NOTION_TEST_CONNECTION_ID (managed OAuth connection for provider 'notion')
+
+interface Ctx {
+  database_id?: string
+  page_id?: string
+  block_id?: string
+}
+
+const env = process.env as Record<string, string>
+const hasEnv = (...keys: string[]) => keys.every(k => !!env[k] && env[k].trim().length > 0)
+const suite = hasEnv(
+  'COMMANDABLE_MANAGED_OAUTH_BASE_URL',
+  'COMMANDABLE_MANAGED_OAUTH_SECRET_KEY',
+  'NOTION_TEST_CONNECTION_ID',
+)
+  ? describe
+  : describe.skip
+
+suite('notion read handlers (live)', () => {
+  const ctx: Ctx = {}
+  let buildHandler: (name: string) => ((input: any) => Promise<any>)
+
+  beforeAll(async () => {
+    const { COMMANDABLE_MANAGED_OAUTH_BASE_URL, COMMANDABLE_MANAGED_OAUTH_SECRET_KEY, NOTION_TEST_CONNECTION_ID } = env
+
+    const proxy = new IntegrationProxy({
+      managedOAuthBaseUrl: COMMANDABLE_MANAGED_OAUTH_BASE_URL,
+      managedOAuthSecretKey: COMMANDABLE_MANAGED_OAUTH_SECRET_KEY,
+    })
+    const integrationNode = { id: 'node-notion', type: 'notion', label: 'Notion', connectionId: NOTION_TEST_CONNECTION_ID } as any
+
+    const tools = loadIntegrationTools('notion')
+    expect(tools).toBeTruthy()
+
+    buildHandler = (name: string) => {
+      const tool = tools!.read.find(t => t.name === name)
+      expect(tool, `tool ${name} exists`).toBeTruthy()
+      const integration = {
+        fetch: (path: string, init?: RequestInit) => proxy.call(integrationNode, path, init),
+      }
+      const build = new Function('integration', `return (${tool!.handlerCode});`)
+      return build(integration) as (input: any) => Promise<any>
+    }
+
+    // Try to discover some IDs via search
+    const search = buildHandler('search')
+    const searchRes = await search({ query: '' })
+    const page = searchRes?.results?.find((r: any) => r.object === 'page')
+    const database = searchRes?.results?.find((r: any) => r.object === 'database')
+    ctx.page_id = page?.id
+    ctx.database_id = database?.id
+    if (ctx.page_id)
+      ctx.block_id = ctx.page_id
+  }, 60000)
+
+  it('search returns results', async () => {
+    const handler = buildHandler('search')
+    const result = await handler({ query: '' })
+    expect(result).toBeTruthy()
+  }, 30000)
+
+  it('retrieve_page returns a page', async () => {
+    if (!ctx.page_id)
+      return expect(true).toBe(true)
+    const handler = buildHandler('retrieve_page')
+    const result = await handler({ page_id: ctx.page_id })
+    expect(result?.object).toBe('page')
+  }, 30000)
+
+  it('retrieve_database returns a database', async () => {
+    if (!ctx.database_id)
+      return expect(true).toBe(true)
+    const handler = buildHandler('retrieve_database')
+    const result = await handler({ database_id: ctx.database_id })
+    expect(result?.object).toBe('database')
+  }, 30000)
+
+  it('query_database returns results', async () => {
+    if (!ctx.database_id)
+      return expect(true).toBe(true)
+    const handler = buildHandler('query_database')
+    const result = await handler({ database_id: ctx.database_id, page_size: 3 })
+    expect(result?.results).toBeTruthy()
+  }, 30000)
+
+  it('retrieve_block returns a block', async () => {
+    if (!ctx.block_id)
+      return expect(true).toBe(true)
+    const handler = buildHandler('retrieve_block')
+    const result = await handler({ block_id: ctx.block_id })
+    expect(result?.object).toBeTruthy()
+  }, 30000)
+
+  it('list_block_children returns children', async () => {
+    if (!ctx.block_id)
+      return expect(true).toBe(true)
+    const handler = buildHandler('list_block_children')
+    const result = await handler({ block_id: ctx.block_id, page_size: 5 })
+    expect(Array.isArray(result?.results)).toBe(true)
+  }, 30000)
+
+  it('list_users returns users', async () => {
+    const handler = buildHandler('list_users')
+    const result = await handler({ page_size: 5 })
+    expect(result).toBeTruthy()
+  }, 30000)
+
+  it('get_me returns current user', async () => {
+    const handler = buildHandler('get_me')
+    const result = await handler({})
+    expect(result).toBeTruthy()
+  }, 30000)
+
+  it('retrieve_user returns a user', async () => {
+    const list = buildHandler('list_users')
+    const users = await list({ page_size: 1 })
+    const uid = users?.results?.[0]?.id
+    if (!uid)
+      return expect(true).toBe(true)
+    const handler = buildHandler('retrieve_user')
+    const result = await handler({ user_id: uid })
+    expect(result?.id).toBe(uid)
+  }, 30000)
+
+  it('retrieve_page_property_item returns property data', async () => {
+    if (!ctx.page_id)
+      return expect(true).toBe(true)
+    const page = buildHandler('retrieve_page')
+    const p = await page({ page_id: ctx.page_id })
+    const propId = Object.values(p?.properties || {})?.[0]?.id
+    if (!propId)
+      return expect(true).toBe(true)
+    const handler = buildHandler('retrieve_page_property_item')
+    const result = await handler({ page_id: ctx.page_id, property_id: propId, page_size: 5 })
+    expect(result).toBeTruthy()
+  }, 30000)
+
+  it('list_comments returns comments for page or block', async () => {
+    if (!ctx.page_id)
+      return expect(true).toBe(true)
+    const handler = buildHandler('list_comments')
+    const result = await handler({ block_id: ctx.page_id })
+    expect(result).toBeTruthy()
+  }, 30000)
+})