@commandable/integration-data 0.4.0 → 0.4.1

package/integrations/__tests__/liveHarness.ts

@@ -0,0 +1,97 @@
+import { IntegrationProxy } from '../../../core/src/integrations/proxy.js'
+import { loadIntegrationTools } from '../../../core/src/integrations/dataLoader.js'
+import { createSafeHandlerFromString } from '../../../core/src/integrations/sandbox.js'
+import { buildSandboxUtils } from '../../../core/src/integrations/sandboxUtils.js'
+
+type ToolDef = {
+  name: string
+  handlerCode: string
+  utils?: string[]
+}
+
+type ToolSet = {
+  read: ToolDef[]
+  write: ToolDef[]
+  admin: ToolDef[]
+}
+
+export function hasEnv(...keys: string[]) {
+  const env = process.env as Record<string, string | undefined>
+  return keys.every(k => Boolean(env[k] && String(env[k]).trim().length > 0))
+}
+
+export function safeCleanup(fn: () => Promise<any>) {
+  return fn().catch(() => {})
+}
+
+export function createCredentialStore(getCredentials: () => Promise<any>) {
+  return { getCredentials }
+}
+
+export function createIntegrationNode(type: string, opts?: { id?: string, label?: string, credentialId?: string, credentialVariant?: string }) {
+  const id = opts?.id || `node-${type}`
+  return {
+    spaceId: 'ci',
+    id,
+    referenceId: id,
+    type,
+    label: opts?.label || type,
+    connectionMethod: 'credentials',
+    credentialId: opts?.credentialId || `${type}-creds`,
+    credentialVariant: opts?.credentialVariant,
+  } as any
+}
+
+export function createProxy(credentialStore: { getCredentials: () => Promise<any> }) {
+  return new IntegrationProxy({ credentialStore })
+}
+
+function getTools(type: string, credentialVariant?: string): ToolSet {
+  const tools = loadIntegrationTools(type, { credentialVariant })
+  if (!tools)
+    throw new Error(`Missing integration tools for '${type}'`)
+  return tools as any
+}
+
+function compileTool(proxy: IntegrationProxy, node: any, tool: ToolDef) {
+  const integration = { fetch: (path: string, init?: RequestInit) => proxy.call(node, path, init) }
+  const wrapper = `async (input) => {\n  const integration = getIntegration('${String(node?.id || 'node')}');\n  const __inner = ${tool.handlerCode};\n  return await __inner(input);\n}`
+  const utils = buildSandboxUtils(Array.isArray(tool.utils) ? tool.utils : undefined)
+  const safeHandler = createSafeHandlerFromString(wrapper, () => integration, utils)
+  return async (input: any) => {
+    const res = await safeHandler(input)
+    if (!res.success)
+      throw res.result
+    return res.result
+  }
+}
+
+export function createToolbox(type: string, proxy: IntegrationProxy, node: any, credentialVariant?: string) {
+  const tools = getTools(type, credentialVariant)
+
+  const findTool = (scope: keyof ToolSet, name: string) => tools[scope].find(t => t.name === name)
+
+  return {
+    /** Returns true if the tool exists in this variant's toolset. */
+    hasTool: (scope: keyof ToolSet, name: string) => !!findTool(scope, name),
+
+    read: (name: string) => {
+      const tool = findTool('read', name)
+      if (!tool)
+        throw new Error(`Missing read tool '${name}' for '${type}' (variant: ${credentialVariant ?? 'default'})`)
+      return compileTool(proxy, node, tool)
+    },
+    write: (name: string) => {
+      const tool = findTool('write', name)
+      if (!tool)
+        throw new Error(`Missing write tool '${name}' for '${type}' (variant: ${credentialVariant ?? 'default'})`)
+      return compileTool(proxy, node, tool)
+    },
+    admin: (name: string) => {
+      const tool = findTool('admin', name) || findTool('write', name) || findTool('read', name)
+      if (!tool)
+        throw new Error(`Missing admin tool '${name}' for '${type}' (variant: ${credentialVariant ?? 'default'})`)
+      return compileTool(proxy, node, tool)
+    },
+  }
+}

package/integrations/__tests__/usageParity.ts

@@ -0,0 +1,54 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { loadIntegrationManifest } from '../../../core/src/integrations/dataLoader.js'
+
+function escapeRegExp(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+/**
+ * Returns tool names from the manifest that are not exercised in any test file,
+ * excluding tools that are restricted to specific credential variants (those are
+ * covered by their own variant-specific test suites).
+ */
+export function getMissingToolUsages(opts: { integrationName: string, importMetaUrl: string, credentialVariant?: string }): string[] {
+  const manifest = loadIntegrationManifest(opts.integrationName)
+  if (!manifest)
+    throw new Error(`Missing integration manifest for '${opts.integrationName}'`)
+
+  const tools = manifest.tools as any[]
+
+  const relevantTools = tools.filter((t) => {
+    if (!t.credentialVariants || !Array.isArray(t.credentialVariants) || t.credentialVariants.length === 0)
+      return true
+    if (opts.credentialVariant)
+      return t.credentialVariants.includes(opts.credentialVariant)
+    return false
+  })
+
+  const toolNames = relevantTools.map(t => t.name)
+
+  const testsDir = fileURLToPath(new URL('.', opts.importMetaUrl))
+  if (!existsSync(testsDir))
+    throw new Error(`Missing tests directory: ${testsDir}`)
+
+  const testFiles = readdirSync(testsDir)
+    .filter(f => /\.test\.(t|j)s$/.test(f) && !f.includes('usage_parity.test'))
+    .map(f => resolve(testsDir, f))
+
+  const fileContents = testFiles.map(f => readFileSync(f, 'utf8'))
+
+  const missing: string[] = []
+  for (const name of toolNames) {
+    const nameRe = new RegExp(
+      `(?:build(?:Read|Write|Admin)?(?:Handler)?|\\.(?:read|write|admin))\\(\\s*['\"\`]${escapeRegExp(name)}['\"\`]\\s*\\)`,
+      'm',
+    )
+    const found = fileContents.some(src => nameRe.test(src))
+    if (!found)
+      missing.push(name)
+  }
+
+  return missing
+}

package/integrations/airtable/.env.test.example

@@ -0,0 +1,11 @@
+# Airtable live integration tests
+#
+# Get a personal access token at: https://airtable.com/create/tokens
+# Ensure it has access to the base below with data.records:read + data.records:write.
+AIRTABLE_TOKEN=
+#
+# Required for write tests (the suite creates/updates/deletes records; it does NOT create
+# bases/tables). Base/table IDs can be found in the Airtable UI/API docs for your base.
+# The table must have a writable text field named `Name`.
+AIRTABLE_TEST_WRITE_BASE_ID=
+AIRTABLE_TEST_WRITE_TABLE_ID=

package/integrations/airtable/README.md

@@ -0,0 +1,27 @@
+# Airtable
+
+**11 tools**
+
+![Airtable tests](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/theomccabe/771bd329f303087690c522afa1baa6f3/raw/test-airtable.json)
+
+## Credential variants
+
+| Variant | Label |
+|---|---|
+| `personal_access_token` | Personal Access Token _(default)_ |
+
+## Tools
+
+| Tool | Scope | Description |
+|---|---|---|
+| `list_bases` | read | List bases available to the authenticated user. |
+| `list_tables` | read | List tables in a base (metadata). |
+| `get_table_schema` | read | Fetch a table's schema (fields, views) by tableId via metadata. |
+| `list_table_fields` | read | List fields for a table (metadata). |
+| `list_views` | read | List views for a table (metadata). |
+| `list_records` | read | List records from a table with optional filters. |
+| `get_record` | read | Fetch a single record by recordId. |
+| `search_records` | read | Search records in a table using a field and value (filterByFormula). |
+| `create_record` | write | Create a record in a table. |
+| `update_record` | write | Update a record in a table. |
+| `delete_record` | write | Delete a record from a table. |

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

@@ -0,0 +1,187 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { IntegrationProxy } from '../../../../core/src/integrations/proxy.js'
+import { loadIntegrationTools } from '../../../../core/src/integrations/dataLoader.js'
+
+// LIVE Airtable integration tests using credentials
+// Required env vars:
+// - AIRTABLE_TOKEN
+// Optional (pins read tests to a specific base/table instead of auto-discovering):
+// - AIRTABLE_TEST_WRITE_BASE_ID
+// - AIRTABLE_TEST_WRITE_TABLE_ID
+
+interface Ctx {
+  baseId?: string
+  tableId?: string
+  recordId?: string
+  ownedRecordId?: 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(
+  'AIRTABLE_TOKEN',
+)
+  ? describe
+  : describe.skip
+
+suite('airtable read handlers (live)', () => {
+  const ctx: Ctx = {}
+  let buildHandler: (name: string) => ((input: any) => Promise<any>)
+  let buildWriteHandler: (name: string) => ((input: any) => Promise<any>)
+
+  beforeAll(async () => {
+    const credentialStore = {
+      getCredentials: async () => ({ token: env.AIRTABLE_TOKEN || '' }),
+    }
+
+    const proxy = new IntegrationProxy({ credentialStore })
+    const integrationNode = {
+      spaceId: 'ci',
+      id: 'node-airtable',
+      referenceId: 'node-airtable',
+      type: 'airtable',
+      label: 'Airtable',
+      connectionMethod: 'credentials',
+      credentialId: 'airtable-creds',
+    } as any
+
+    const tools = loadIntegrationTools('airtable')
+    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>
+    }
+
+    buildWriteHandler = (name: string) => {
+      const tool = tools!.write.find(t => t.name === name)
+      expect(tool, `write 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>
+    }
+
+    // Use explicit test base/table if provided, otherwise auto-discover from first base
+    if (env.AIRTABLE_TEST_WRITE_BASE_ID && env.AIRTABLE_TEST_WRITE_TABLE_ID) {
+      ctx.baseId = env.AIRTABLE_TEST_WRITE_BASE_ID
+      ctx.tableId = env.AIRTABLE_TEST_WRITE_TABLE_ID
+    }
+    else {
+      const list_bases = buildHandler('list_bases')
+      const bases = await list_bases({})
+      ctx.baseId = bases?.bases?.[0]?.id || bases?.[0]?.id
+
+      if (ctx.baseId) {
+        const list_tables = buildHandler('list_tables')
+        const tablesResp = await list_tables({ baseId: ctx.baseId })
+        const tables = tablesResp?.tables || tablesResp
+        ctx.tableId = tables?.[0]?.id
+      }
+    }
+
+    // Create a dedicated record so get_record has a stable ID that the concurrent
+    // write suite cannot accidentally delete out from under us.
+    if (ctx.baseId && ctx.tableId) {
+      try {
+        const create_record = buildWriteHandler('create_record')
+        const created = await create_record({
+          baseId: ctx.baseId,
+          tableId: ctx.tableId,
+          fields: { Name: `ReadTest ${Date.now()}` },
+        })
+        const rec = created?.records?.[0] || created
+        ctx.ownedRecordId = rec?.id
+        ctx.recordId = rec?.id
+      }
+      catch {
+        // If create fails (e.g. no write permission), fall back to discovering a record
+        const list_records = buildHandler('list_records')
+        const recs = await list_records({ baseId: ctx.baseId, tableId: ctx.tableId, pageSize: 1 })
+        const records = recs?.records || recs
+        ctx.recordId = records?.[0]?.id
+      }
+    }
+  }, 60000)
+
+  afterAll(async () => {
+    if (ctx.ownedRecordId && ctx.baseId && ctx.tableId) {
+      try {
+        const delete_record = buildWriteHandler('delete_record')
+        await delete_record({ baseId: ctx.baseId, tableId: ctx.tableId, recordId: ctx.ownedRecordId })
+      }
+      catch {}
+    }
+  })
+
+  it('list_bases returns bases', async () => {
+    const handler = buildHandler('list_bases')
+    const result = await handler({})
+    expect(result).toBeTruthy()
+  }, 30000)
+
+  it('list_tables returns tables for base', async () => {
+    if (!ctx.baseId)
+      return expect(true).toBe(true)
+    const handler = buildHandler('list_tables')
+    const result = await handler({ baseId: ctx.baseId })
+    expect(result).toBeTruthy()
+  }, 30000)
+
+  it('get_table_schema returns a table schema', async () => {
+    if (!ctx.baseId || !ctx.tableId)
+      return expect(true).toBe(true)
+    const handler = buildHandler('get_table_schema')
+    const result = await handler({ baseId: ctx.baseId, tableId: ctx.tableId })
+    expect(result?.id || result?.name).toBeTruthy()
+  }, 30000)
+
+  it('list_table_fields returns fields', async () => {
+    if (!ctx.baseId || !ctx.tableId)
+      return expect(true).toBe(true)
+    const handler = buildHandler('list_table_fields')
+    const result = await handler({ baseId: ctx.baseId, tableId: ctx.tableId })
+    expect(Array.isArray(result)).toBe(true)
+  }, 30000)
+
+  it('list_views returns views', async () => {
+    if (!ctx.baseId || !ctx.tableId)
+      return expect(true).toBe(true)
+    const handler = buildHandler('list_views')
+    const result = await handler({ baseId: ctx.baseId, tableId: ctx.tableId })
+    expect(Array.isArray(result)).toBe(true)
+  }, 30000)
+
+  it('list_records returns records', async () => {
+    if (!ctx.baseId || !ctx.tableId)
+      return expect(true).toBe(true)
+    const handler = buildHandler('list_records')
+    const result = await handler({ baseId: ctx.baseId, tableId: ctx.tableId, pageSize: 3 })
+    expect(result).toBeTruthy()
+  }, 30000)
+
+  it('get_record returns a record by id', async () => {
+    if (!ctx.baseId || !ctx.tableId || !ctx.recordId)
+      return expect(true).toBe(true)
+    const handler = buildHandler('get_record')
+    const result = await handler({ baseId: ctx.baseId, tableId: ctx.tableId, recordId: ctx.recordId })
+    expect(result?.id).toBe(ctx.recordId)
+  }, 30000)
+
+  it('search_records returns matching records', async () => {
+    if (!ctx.baseId || !ctx.tableId)
+      return expect(true).toBe(true)
+    const list_fields = buildHandler('list_table_fields')
+    const fields: any[] = await list_fields({ baseId: ctx.baseId, tableId: ctx.tableId })
+    const fieldName = fields?.[0]?.name || 'Name'
+    const handler = buildHandler('search_records')
+    const result = await handler({ baseId: ctx.baseId, tableId: ctx.tableId, field: fieldName, value: '' })
+    expect(result).toBeTruthy()
+  }, 30000)
+})

package/integrations/airtable/__tests__/usage_parity.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest'
+import { getMissingToolUsages } from '../../__tests__/usageParity.js'
+
+describe('airtable static usage parity', () => {
+  it('every manifest tool is referenced in tests', () => {
+    const missing = getMissingToolUsages({ integrationName: 'airtable', importMetaUrl: import.meta.url })
+    expect(missing, `Missing handler usages in tests: ${missing.join(', ')}`).toEqual([])
+  })
+})

package/integrations/airtable/__tests__/write_and_admin_handlers.test.ts

@@ -0,0 +1,116 @@
+import { beforeAll, describe, expect, it } from 'vitest'
+import { IntegrationProxy } from '../../../../core/src/integrations/proxy.js'
+import { loadIntegrationTools } from '../../../../core/src/integrations/dataLoader.js'
+
+// LIVE Airtable write tests using credentials
+// Required env vars:
+// - AIRTABLE_TOKEN
+// Optional env for choosing base/table (otherwise picks first available):
+// - AIRTABLE_TEST_WRITE_BASE_ID
+// - AIRTABLE_TEST_WRITE_TABLE_ID
+
+interface Ctx {
+  baseId?: string
+  tableId?: string
+  createdRecordId?: 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(
+  'AIRTABLE_TOKEN',
+)
+  ? describe
+  : describe.skip
+
+suite('airtable write handlers (live)', () => {
+  const ctx: Ctx = {}
+  let buildWriteHandler: (name: string) => ((input: any) => Promise<any>)
+  let buildReadHandler: (name: string) => ((input: any) => Promise<any>)
+
+  beforeAll(async () => {
+    const credentialStore = {
+      getCredentials: async () => ({ token: env.AIRTABLE_TOKEN || '' }),
+    }
+
+    const proxy = new IntegrationProxy({ credentialStore })
+    const integrationNode = {
+      spaceId: 'ci',
+      id: 'node-airtable',
+      referenceId: 'node-airtable',
+      type: 'airtable',
+      label: 'Airtable',
+      connectionMethod: 'credentials',
+      credentialId: 'airtable-creds',
+    } as any
+
+    const tools = loadIntegrationTools('airtable')
+    expect(tools).toBeTruthy()
+
+    buildWriteHandler = (name: string) => {
+      const tool = tools!.write.find(t => t.name === name)
+      expect(tool, `write 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>
+    }
+
+    buildReadHandler = (name: string) => {
+      const tool = tools!.read.find(t => t.name === name)
+      expect(tool, `read 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>
+    }
+
+    // Resolve base/table for write tests
+    ctx.baseId = env.AIRTABLE_TEST_WRITE_BASE_ID
+    ctx.tableId = env.AIRTABLE_TEST_WRITE_TABLE_ID
+
+    if (!ctx.baseId || !ctx.tableId) {
+      const list_bases = buildReadHandler('list_bases')
+      const bases = await list_bases({})
+      ctx.baseId = ctx.baseId || (bases?.bases?.[0]?.id || bases?.[0]?.id)
+      if (ctx.baseId) {
+        const list_tables = buildReadHandler('list_tables')
+        const tablesResp = await list_tables({ baseId: ctx.baseId })
+        const tables = tablesResp?.tables || tablesResp
+        ctx.tableId = ctx.tableId || tables?.[0]?.id
+      }
+    }
+  }, 60000)
+
+  it('create_record -> get_record -> update_record -> delete_record roundtrip', async () => {
+    if (!ctx.baseId || !ctx.tableId)
+      return expect(true).toBe(true)
+
+    // Assume a single writable column named 'Name' per test setup
+    const fieldName = 'Name'
+
+    // Create
+    const create_record = buildWriteHandler('create_record')
+    const created = await create_record({ baseId: ctx.baseId, tableId: ctx.tableId, fields: { [fieldName]: `CmdTest ${Date.now()}` } })
+    const createdRec = created?.records?.[0] || created
+    expect(createdRec?.id).toBeTruthy()
+    ctx.createdRecordId = createdRec.id
+
+    // Read
+    const get_record = buildReadHandler('get_record')
+    const got = await get_record({ baseId: ctx.baseId, tableId: ctx.tableId, recordId: ctx.createdRecordId })
+    expect(got?.id).toBe(ctx.createdRecordId)
+
+    // Update
+    const update_record = buildWriteHandler('update_record')
+    const updated = await update_record({ baseId: ctx.baseId, tableId: ctx.tableId, recordId: ctx.createdRecordId, fields: { [fieldName]: `CmdTest Updated ${Date.now()}` } })
+    const updatedRec = updated?.records?.[0] || updated
+    expect(updatedRec?.id).toBe(ctx.createdRecordId)
+
+    // Delete
+    const delete_record = buildWriteHandler('delete_record')
+    const del = await delete_record({ baseId: ctx.baseId, tableId: ctx.tableId, recordId: ctx.createdRecordId })
+    const deletedRec = del?.records?.[0] || del
+    expect(deletedRec?.deleted === true || deletedRec?.id === ctx.createdRecordId).toBe(true)
+  }, 90000)
+})
+
+// Admin operations are not available on standard plans; omitted.

package/integrations/airtable/credentials.json

@@ -0,0 +1,26 @@
+{
+  "variants": {
+    "personal_access_token": {
+      "label": "Personal Access Token",
+      "schema": {
+        "type": "object",
+        "properties": {
+          "token": {
+            "type": "string",
+            "title": "Personal Access Token",
+            "description": "Airtable personal access token."
+          }
+        },
+        "required": ["token"],
+        "additionalProperties": false
+      },
+      "injection": {
+        "headers": {
+          "Authorization": "Bearer {{token}}"
+        }
+      },
+      "healthCheck": { "path": "/meta/whoami" }
+    }
+  },
+  "default": "personal_access_token"
+}

package/integrations/airtable/credentials_hint.md

@@ -0,0 +1,4 @@
+Create an Airtable personal access token and paste it here.
+
+You can generate one in Airtable account settings under developer tools / personal access tokens.
+

package/integrations/airtable/handlers/create_record.js

@@ -0,0 +1,12 @@
+async (input) => {
+  const path = `/${input.baseId}/${input.tableId}`
+  const body = {
+    records: [
+      { fields: input.fields },
+    ],
+    typecast: !!input.typecast,
+  }
+  const res = await integration.fetch(path, { method: 'POST', body })
+  const data = await res.json()
+  return data
+}

package/integrations/airtable/handlers/delete_record.js

@@ -0,0 +1,7 @@
+async (input) => {
+  const path = `/${input.baseId}/${input.tableId}`
+  const params = new URLSearchParams()
+  params.set('records[]', input.recordId)
+  const res = await integration.fetch(`${path}?${params.toString()}`, { method: 'DELETE' })
+  return await res.json()
+}

package/integrations/airtable/handlers/get_record.js

@@ -0,0 +1,4 @@
+async (input) => {
+  const res = await integration.fetch(`/${input.baseId}/${input.tableId}/${input.recordId}`)
+  return await res.json()
+}

package/integrations/airtable/handlers/get_table_schema.js

@@ -0,0 +1,6 @@
+async (input) => {
+  const res = await integration.fetch(`/meta/bases/${input.baseId}/tables`)
+  const data = await res.json()
+  const table = (data?.tables || data)?.find?.(t => t.id === input.tableId || t.name === input.tableId)
+  return table || null
+}

package/integrations/airtable/handlers/list_bases.js

@@ -0,0 +1,4 @@
+async (input) => {
+  const res = await integration.fetch(`/meta/bases`)
+  return await res.json()
+}

package/integrations/airtable/handlers/list_records.js

@@ -0,0 +1,25 @@
+async (input) => {
+  const params = new URLSearchParams()
+  if (input.view)
+    params.set('view', input.view)
+  if (input.maxRecords)
+    params.set('maxRecords', String(input.maxRecords))
+  if (input.pageSize)
+    params.set('pageSize', String(input.pageSize))
+  if (input.filterByFormula)
+    params.set('filterByFormula', input.filterByFormula)
+  if (input.sort && Array.isArray(input.sort)) {
+    input.sort.forEach((s, i) => {
+      if (s && typeof s === 'object') {
+        if (s.field)
+          params.set(`sort[${i}][field]`, String(s.field))
+        if (s.direction)
+          params.set(`sort[${i}][direction]`, String(s.direction))
+      }
+    })
+  }
+  const qs = params.toString()
+  const path = `/${input.baseId}/${input.tableId}${qs ? `?${qs}` : ''}`
+  const res = await integration.fetch(path)
+  return await res.json()
+}

package/integrations/airtable/handlers/list_table_fields.js

@@ -0,0 +1,6 @@
+async (input) => {
+  const res = await integration.fetch(`/meta/bases/${input.baseId}/tables`)
+  const data = await res.json()
+  const table = (data?.tables || data)?.find?.(t => t.id === input.tableId || t.name === input.tableId)
+  return table?.fields || []
+}

package/integrations/airtable/handlers/list_tables.js

@@ -0,0 +1,4 @@
+async (input) => {
+  const res = await integration.fetch(`/meta/bases/${input.baseId}/tables`)
+  return await res.json()
+}

package/integrations/airtable/handlers/list_views.js

@@ -0,0 +1,6 @@
+async (input) => {
+  const res = await integration.fetch(`/meta/bases/${input.baseId}/tables`)
+  const data = await res.json()
+  const table = (data?.tables || data)?.find?.(t => t.id === input.tableId || t.name === input.tableId)
+  return table?.views || []
+}

package/integrations/airtable/handlers/search_records.js

@@ -0,0 +1,6 @@
+async (input) => {
+  const formula = `{${input.field}} = "${input.value}"`
+  const params = new URLSearchParams({ filterByFormula: formula })
+  const res = await integration.fetch(`/${input.baseId}/${input.tableId}?${params.toString()}`)
+  return await res.json()
+}

package/integrations/airtable/handlers/update_record.js

@@ -0,0 +1,11 @@
+async (input) => {
+  const path = `/${input.baseId}/${input.tableId}`
+  const body = {
+    records: [
+      { id: input.recordId, fields: input.fields },
+    ],
+    typecast: !!input.typecast,
+  }
+  const res = await integration.fetch(path, { method: 'PATCH', body })
+  return await res.json()
+}