@commandable/integration-data 0.0.1 → 0.0.5

package/integrations/google-drive/__tests__/handlers.test.ts

@@ -0,0 +1,102 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { createCredentialStore, createIntegrationNode, createProxy, createToolbox, safeCleanup } from '../../__tests__/liveHarness.js'
+
+// LIVE Google Drive tests -- runs once per available credential variant.
+// Required env vars (at least one):
+// - GOOGLE_SERVICE_ACCOUNT_JSON  (service_account variant)
+// - GOOGLE_TOKEN                 (oauth_token variant)
+
+const env = process.env as Record<string, string | undefined>
+
+interface VariantConfig {
+  key: string
+  credentials: () => Record<string, string>
+}
+
+const variants: VariantConfig[] = [
+  {
+    key: 'service_account',
+    credentials: () => ({ serviceAccountJson: env.GOOGLE_SERVICE_ACCOUNT_JSON || '', subject: env.GOOGLE_IMPERSONATE_SUBJECT || '' }),
+  },
+  {
+    key: 'oauth_token',
+    credentials: () => ({ token: env.GOOGLE_TOKEN || '' }),
+  },
+].filter(v => Object.values(v.credentials()).some(val => val.trim().length > 0))
+
+const suiteOrSkip = variants.length > 0 ? describe : describe.skip
+
+suiteOrSkip('google-drive handlers (live)', () => {
+  for (const variant of variants) {
+    describe(`variant: ${variant.key}`, () => {
+      const ctx: { folderId?: string, fileId?: string, destFolderId?: string } = {}
+      let drive: ReturnType<typeof createToolbox>
+
+      beforeAll(async () => {
+        const credentialStore = createCredentialStore(async () => variant.credentials())
+        const proxy = createProxy(credentialStore)
+        drive = createToolbox(
+          'google-drive',
+          proxy,
+          createIntegrationNode('google-drive', { label: 'Google Drive', credentialId: 'google-drive-creds', credentialVariant: variant.key }),
+          variant.key,
+        )
+
+        const folder = await drive.write('create_folder')({ name: `CmdTest Drive ${Date.now()}` })
+        ctx.folderId = folder?.id
+        expect(ctx.folderId).toBeTruthy()
+
+        const destFolder = await drive.write('create_folder')({ name: `CmdTest Drive Dest ${Date.now()}` })
+        ctx.destFolderId = destFolder?.id
+        expect(ctx.destFolderId).toBeTruthy()
+
+        const file = await drive.write('create_file')({
+          name: `CmdTest File ${Date.now()}`,
+          mimeType: 'application/vnd.google-apps.document',
+          parentId: ctx.folderId,
+        })
+        ctx.fileId = file?.id
+        expect(ctx.fileId).toBeTruthy()
+      }, 60000)
+
+      afterAll(async () => {
+        await safeCleanup(async () => ctx.fileId ? drive.write('delete_file')({ fileId: ctx.fileId }) : Promise.resolve())
+        await safeCleanup(async () => ctx.folderId ? drive.write('delete_file')({ fileId: ctx.folderId }) : Promise.resolve())
+        await safeCleanup(async () => ctx.destFolderId ? drive.write('delete_file')({ fileId: ctx.destFolderId }) : Promise.resolve())
+      }, 60000)
+
+      it('get_file returns file metadata', async () => {
+        if (!ctx.fileId)
+          return expect(true).toBe(true)
+        const result = await drive.read('get_file')({ fileId: ctx.fileId })
+        expect(result?.id).toBe(ctx.fileId)
+        expect(typeof result?.name).toBe('string')
+        expect(typeof result?.mimeType).toBe('string')
+      }, 30000)
+
+      it('move_file moves the file to a different folder', async () => {
+        if (!ctx.fileId || !ctx.destFolderId || !ctx.folderId)
+          return expect(true).toBe(true)
+        const result = await drive.write('move_file')({
+          fileId: ctx.fileId,
+          addParents: ctx.destFolderId,
+          removeParents: ctx.folderId,
+        })
+        expect(result?.id).toBe(ctx.fileId)
+        const meta = await drive.read('get_file')({ fileId: ctx.fileId })
+        expect(meta?.parents).toContain(ctx.destFolderId)
+      }, 30000)
+
+      it('delete_file deletes a file permanently', async () => {
+        const tempFile = await drive.write('create_file')({
+          name: `CmdTest Temp ${Date.now()}`,
+          mimeType: 'application/vnd.google-apps.document',
+        })
+        const tempId = tempFile?.id
+        expect(tempId).toBeTruthy()
+        await drive.write('delete_file')({ fileId: tempId })
+        await expect(drive.read('get_file')({ fileId: tempId })).rejects.toThrow()
+      }, 30000)
+    })
+  }
+})

package/integrations/google-drive/credentials.json

@@ -0,0 +1,57 @@
+{
+  "variants": {
+    "service_account": {
+      "label": "Service Account (recommended)",
+      "schema": {
+        "type": "object",
+        "properties": {
+          "serviceAccountJson": {
+            "type": "string",
+            "title": "Service Account JSON",
+            "description": "Full service account key JSON (contents of the downloaded JSON file from Google Cloud)."
+          },
+          "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. Defaults to drive.",
+            "items": { "type": "string" }
+          }
+        },
+        "required": ["serviceAccountJson"],
+        "additionalProperties": false
+      },
+      "injection": {
+        "headers": {
+          "Authorization": "Bearer {{token}}"
+        }
+      },
+      "preprocess": "google_service_account"
+    },
+    "oauth_token": {
+      "label": "OAuth Access Token (short-lived)",
+      "schema": {
+        "type": "object",
+        "properties": {
+          "token": {
+            "type": "string",
+            "title": "OAuth Access Token",
+            "description": "Short-lived Google OAuth access token with drive scope."
+          }
+        },
+        "required": ["token"],
+        "additionalProperties": false
+      },
+      "injection": {
+        "headers": {
+          "Authorization": "Bearer {{token}}"
+        }
+      }
+    }
+  },
+  "default": "service_account"
+}

package/integrations/google-drive/credentials_hint_oauth_token.md

@@ -0,0 +1,8 @@
+Obtain a short-lived Google OAuth access token:
+
+1. Use the Google OAuth 2.0 Playground (`https://developers.google.com/oauthplayground/`) or your own OAuth flow
+2. Select the scope: `https://www.googleapis.com/auth/drive`
+3. Exchange the authorization code for an access token
+4. Paste the access token here
+
+Note: OAuth access tokens are short-lived (typically 1 hour). For long-running use, prefer the Service Account variant.

package/integrations/google-drive/credentials_hint_service_account.md

@@ -0,0 +1,10 @@
+Set up a Google Cloud Service Account:
+
+1. Open the [Google Cloud Console](https://console.cloud.google.com/)
+2. Enable the **Google Drive API** for your project
+3. Go to **IAM & Admin → Service Accounts** and create a new service account
+4. Under **Keys**, click **Add Key → Create new key → JSON** and download the file
+5. Paste the full contents of the JSON file here
+6. Share the Drive folders/files you want to access with the service account's `client_email`
+
+For Google Workspace users: optionally configure domain-wide delegation and set `subject` to the user's email.

package/integrations/google-drive/handlers/create_file.js

@@ -0,0 +1,15 @@
+async (input) => {
+  const body = {
+    name: input.name,
+    mimeType: input.mimeType,
+  }
+  if (input.parentId)
+    body.parents = [input.parentId]
+
+  const res = await integration.fetch('/files', {
+    method: 'POST',
+    body,
+  })
+  return await res.json()
+}
+

package/integrations/google-drive/handlers/create_folder.js

@@ -0,0 +1,15 @@
+async (input) => {
+  const body = {
+    name: input.name,
+    mimeType: 'application/vnd.google-apps.folder',
+  }
+  if (input.parentId)
+    body.parents = [input.parentId]
+
+  const res = await integration.fetch('/files', {
+    method: 'POST',
+    body,
+  })
+  return await res.json()
+}
+

package/integrations/google-drive/handlers/delete_file.js

@@ -0,0 +1,14 @@
+async (input) => {
+  const res = await integration.fetch(`/files/${encodeURIComponent(input.fileId)}`, {
+    method: 'DELETE',
+  })
+  if (res.status === 204)
+    return { success: true, status: 204 }
+  try {
+    return await res.json()
+  }
+  catch {
+    return { success: res.ok, status: res.status }
+  }
+}
+

package/integrations/google-drive/handlers/get_file.js

@@ -0,0 +1,7 @@
+async (input) => {
+  const res = await integration.fetch(`/files/${encodeURIComponent(input.fileId)}?fields=id,name,mimeType,parents,trashed`, {
+    method: 'GET',
+  })
+  return await res.json()
+}
+

package/integrations/google-drive/handlers/move_file.js

@@ -0,0 +1,12 @@
+async (input) => {
+  const params = new URLSearchParams()
+  params.set('addParents', input.addParents)
+  if (input.removeParents)
+    params.set('removeParents', input.removeParents)
+
+  const res = await integration.fetch(`/files/${encodeURIComponent(input.fileId)}?${params.toString()}`, {
+    method: 'PATCH',
+  })
+  return await res.json()
+}
+

package/integrations/google-drive/manifest.json

@@ -0,0 +1,42 @@
+{
+  "name": "google-drive",
+  "version": "0.1.0",
+  "tools": [
+    {
+      "name": "create_folder",
+      "description": "Create a folder in Google Drive.",
+      "inputSchema": "schemas/create_folder.json",
+      "handler": "handlers/create_folder.js",
+      "scope": "write"
+    },
+    {
+      "name": "create_file",
+      "description": "Create a Drive file (including Google Docs/Sheets/Slides) optionally inside a parent folder.",
+      "inputSchema": "schemas/create_file.json",
+      "handler": "handlers/create_file.js",
+      "scope": "write"
+    },
+    {
+      "name": "move_file",
+      "description": "Move a file to a different parent folder (add/remove parents).",
+      "inputSchema": "schemas/move_file.json",
+      "handler": "handlers/move_file.js",
+      "scope": "write"
+    },
+    {
+      "name": "get_file",
+      "description": "Get a Drive file’s metadata by fileId.",
+      "inputSchema": "schemas/get_file.json",
+      "handler": "handlers/get_file.js",
+      "scope": "read"
+    },
+    {
+      "name": "delete_file",
+      "description": "Permanently delete a Drive file or folder by fileId.",
+      "inputSchema": "schemas/delete_file.json",
+      "handler": "handlers/delete_file.js",
+      "scope": "write"
+    }
+  ]
+}
+

package/integrations/google-drive/schemas/create_file.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["name", "mimeType"],
+  "additionalProperties": false,
+  "properties": {
+    "name": { "type": "string" },
+    "mimeType": { "type": "string", "description": "Drive mimeType (e.g. application/vnd.google-apps.document)" },
+    "parentId": { "type": "string", "description": "Optional parent folder fileId" }
+  }
+}
+

package/integrations/google-drive/schemas/create_folder.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["name"],
+  "additionalProperties": false,
+  "properties": {
+    "name": { "type": "string" },
+    "parentId": { "type": "string", "description": "Optional parent folder fileId" }
+  }
+}
+

package/integrations/google-drive/schemas/delete_file.json

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

package/integrations/google-drive/schemas/get_file.json

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

package/integrations/google-drive/schemas/move_file.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["fileId", "addParents"],
+  "additionalProperties": false,
+  "properties": {
+    "fileId": { "type": "string" },
+    "addParents": { "type": "string", "description": "Comma-separated parent IDs to add" },
+    "removeParents": { "type": "string", "description": "Comma-separated parent IDs to remove (optional)" }
+  }
+}
+

package/integrations/google-sheet/__tests__/get_handlers.test.ts

@@ -1,128 +1,121 @@
-import { beforeAll, describe, expect, it } from 'vitest'
-import { IntegrationProxy } from '../../../src/integrations/proxy.js'
-import { loadIntegrationTools } from '../../../src/integrations/dataLoader.js'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { createCredentialStore, createIntegrationNode, createProxy, createToolbox, hasEnv, safeCleanup } from '../../__tests__/liveHarness.js'
 
-// LIVE Google Sheets read tests using managed OAuth
+// LIVE Google Sheets read tests using credentials
 // Required env vars:
-// - COMMANDABLE_MANAGED_OAUTH_BASE_URL
-// - COMMANDABLE_MANAGED_OAUTH_SECRET_KEY
-// - GSHEETS_TEST_CONNECTION_ID (managed OAuth connection for provider 'google-sheet')
-// - GSHEETS_TEST_SPREADSHEET_ID (an accessible spreadsheet ID)
+// - Either GOOGLE_TOKEN, OR GOOGLE_SERVICE_ACCOUNT_JSON
 
-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',
-  'GSHEETS_TEST_CONNECTION_ID',
-)
+const suite = (hasEnv('GOOGLE_TOKEN') || hasEnv('GOOGLE_SERVICE_ACCOUNT_JSON'))
   ? describe
   : describe.skip
 
 suite('google-sheet read handlers (live)', () => {
-  let buildReadHandler: (name: string) => ((input: any) => Promise<any>)
+  let sheets: ReturnType<typeof createToolbox>
+  let drive: ReturnType<typeof createToolbox>
   let sheetTitle: string | undefined
+  let folderId: string | undefined
+  let spreadsheetId: string | undefined
 
   beforeAll(async () => {
-    const { COMMANDABLE_MANAGED_OAUTH_BASE_URL, COMMANDABLE_MANAGED_OAUTH_SECRET_KEY, GSHEETS_TEST_CONNECTION_ID } = env
+    const env = process.env as Record<string, string | undefined>
+    const credentialStore = createCredentialStore(async () => ({
+      token: env.GOOGLE_TOKEN || '',
+      serviceAccountJson: env.GOOGLE_SERVICE_ACCOUNT_JSON || '',
+      subject: env.GOOGLE_IMPERSONATE_SUBJECT || '',
+    }))
+    const proxy = createProxy(credentialStore)
+    sheets = createToolbox('google-sheet', proxy, createIntegrationNode('google-sheet', { label: 'Google Sheets', credentialId: 'google-sheet-creds' }))
+    drive = createToolbox('google-drive', proxy, createIntegrationNode('google-drive', { label: 'Google Drive', credentialId: 'google-drive-creds' }))
 
-    const proxy = new IntegrationProxy({
-      managedOAuthBaseUrl: COMMANDABLE_MANAGED_OAUTH_BASE_URL,
-      managedOAuthSecretKey: COMMANDABLE_MANAGED_OAUTH_SECRET_KEY,
-    })
-    const integrationNode = { id: 'node-gsheets', type: 'google-sheet', label: 'Google Sheets', connectionId: GSHEETS_TEST_CONNECTION_ID } as any
+    // Create dedicated folder + spreadsheet for this run
+    const folder = await drive.write('create_folder')({ name: `CmdTest Sheets ${Date.now()}` })
+    folderId = folder?.id
+    expect(folderId).toBeTruthy()
 
-    const tools = loadIntegrationTools('google-sheet')
-    expect(tools).toBeTruthy()
+    const created = await drive.write('create_file')({
+      name: `CmdTest Sheet ${Date.now()}`,
+      mimeType: 'application/vnd.google-apps.spreadsheet',
+      parentId: folderId,
+    })
+    spreadsheetId = created?.id
+    expect(spreadsheetId).toBeTruthy()
 
-    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>
+    try {
+      const get_spreadsheet = sheets.read('get_spreadsheet')
+      const meta = await get_spreadsheet({ spreadsheetId })
+      sheetTitle = meta?.sheets?.[0]?.properties?.title
     }
+    catch {}
+  }, 60000)
 
-    // Try to detect a default sheet title
-    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
-    if (spreadsheetId) {
-      try {
-        const get_spreadsheet = buildReadHandler('get_spreadsheet')
-        const meta = await get_spreadsheet({ spreadsheetId })
-        sheetTitle = meta?.sheets?.[0]?.properties?.title
-      }
-      catch {}
-    }
+  afterAll(async () => {
+    if (!folderId)
+      return
+    await safeCleanup(async () => spreadsheetId ? drive.write('delete_file')({ fileId: spreadsheetId }) : Promise.resolve())
+    await safeCleanup(async () => drive.write('delete_file')({ fileId: folderId }))
   }, 60000)
 
   it('get_spreadsheet returns metadata', async () => {
-    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
     if (!spreadsheetId)
       return expect(true).toBe(true)
-    const handler = buildReadHandler('get_spreadsheet')
+    const handler = sheets.read('get_spreadsheet')
     const result = await handler({ spreadsheetId })
     expect(result?.spreadsheetId || result?.sheets).toBeTruthy()
   }, 30000)
 
   it('get_values returns a value range', async () => {
-    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
     if (!spreadsheetId)
       return expect(true).toBe(true)
-    const handler = buildReadHandler('get_values')
+    const handler = sheets.read('get_values')
     const range = sheetTitle ? `${sheetTitle}!A1:B5` : 'A1:B5'
     const result = await handler({ spreadsheetId, range })
     expect(result?.range || result?.values).toBeTruthy()
   }, 30000)
 
   it('batch_get_values returns multiple ranges', async () => {
-    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
     if (!spreadsheetId)
       return expect(true).toBe(true)
-    const handler = buildReadHandler('batch_get_values')
+    const handler = sheets.read('batch_get_values')
     const aTitle = sheetTitle || 'Sheet1'
     const result = await handler({ spreadsheetId, ranges: [`${aTitle}!A1:A3`, `${aTitle}!B1:B3`] })
     expect(Array.isArray(result?.valueRanges)).toBe(true)
   }, 30000)
 
   it('get_spreadsheet_by_data_filter returns metadata', async () => {
-    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
     if (!spreadsheetId)
       return expect(true).toBe(true)
-    const handler = buildReadHandler('get_spreadsheet_by_data_filter')
+    const handler = sheets.read('get_spreadsheet_by_data_filter')
     const aTitle = sheetTitle || 'Sheet1'
     const result = await handler({ spreadsheetId, dataFilters: [{ a1Range: `${aTitle}!A1:A1` }] })
     expect(result?.spreadsheetId || result?.sheets).toBeTruthy()
   }, 30000)
 
   it('get_values_by_data_filter returns values', async () => {
-    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
     if (!spreadsheetId)
       return expect(true).toBe(true)
-    const handler = buildReadHandler('get_values_by_data_filter')
+    const handler = sheets.read('get_values_by_data_filter')
     const aTitle = sheetTitle || 'Sheet1'
     const result = await handler({ spreadsheetId, dataFilters: [{ a1Range: `${aTitle}!A1:B2` }] })
     expect(Array.isArray(result?.valueRanges)).toBe(true)
   }, 30000)
 
   it('search_developer_metadata returns results or empty', async () => {
-    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
     if (!spreadsheetId)
       return expect(true).toBe(true)
-    const handler = buildReadHandler('search_developer_metadata')
+    const handler = sheets.read('search_developer_metadata')
     const result = await handler({ spreadsheetId, dataFilters: [{ developerMetadataLookup: { visibility: 'DOCUMENT' } }] })
     expect(result !== undefined).toBe(true)
   }, 30000)
 
   it('get_developer_metadata retrieves by id when available', async () => {
-    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
     if (!spreadsheetId)
       return expect(true).toBe(true)
-    const search = buildReadHandler('search_developer_metadata')
+    const search = sheets.read('search_developer_metadata')
     const list = await search({ spreadsheetId, dataFilters: [{ developerMetadataLookup: { visibility: 'DOCUMENT' } }] })
     const first = list?.matchedDeveloperMetadata?.[0]?.developerMetadata || list?.developerMetadata?.[0]
     if (!first?.metadataId)
       return expect(true).toBe(true)
-    const getdm = buildReadHandler('get_developer_metadata')
+    const getdm = sheets.read('get_developer_metadata')
     const got = await getdm({ spreadsheetId, metadataId: first.metadataId })
     expect(got?.metadataId).toBe(first.metadataId)
   }, 30000)

package/integrations/google-sheet/__tests__/usage_parity.test.ts

@@ -1,35 +1,9 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
 import { describe, expect, it } from 'vitest'
-import { loadIntegrationManifest } from '../../../src/integrations/dataLoader.js'
-
-function escapeRegExp(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
+import { getMissingToolUsages } from '../../__tests__/usageParity.js'
 
 describe('google-sheet static usage parity', () => {
-  it('every manifest tool is referenced in tests via build*(name)', () => {
-    const manifest = loadIntegrationManifest('google-sheet')!
-    const toolNames = (manifest.tools as any[]).map(t => t.name)
-
-    const testsDir = fileURLToPath(new URL('.', import.meta.url))
-    expect(existsSync(testsDir)).toBe(true)
-    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) {
-      // Matches buildRead('x'), buildWrite('x'), buildAdmin('x'), buildHandler('x'), buildReadHandler('x'), buildWriteHandler('x')
-      const nameRe = new RegExp(`build(?:Read|Write|Admin)?(?:Handler)?\\(\\s*['\"\`]${escapeRegExp(name)}['\"\`]\\s*\\)`, 'm')
-      const found = fileContents.some(src => nameRe.test(src))
-      if (!found)
-        missing.push(name)
-    }
-
+  it('every manifest tool is referenced in tests', () => {
+    const missing = getMissingToolUsages({ integrationName: 'google-sheet', importMetaUrl: import.meta.url })
     expect(missing, `Missing handler usages in tests: ${missing.join(', ')}`).toEqual([])
   })
 })