@commandable/integration-data 0.0.1

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

@@ -0,0 +1,117 @@
+import { beforeAll, describe, expect, it } from 'vitest'
+import { IntegrationProxy } from '../../../src/integrations/proxy.js'
+import { loadIntegrationTools } from '../../../src/integrations/dataLoader.js'
+
+// LIVE GitHub integration tests using managed OAuth
+// Required env vars:
+// - COMMANDABLE_MANAGED_OAUTH_BASE_URL
+// - COMMANDABLE_MANAGED_OAUTH_SECRET_KEY
+// - GITHUB_TEST_CONNECTION_ID (managed OAuth connection for provider 'github')
+
+interface Ctx {
+  owner?: string
+  repo?: string
+  issue_number?: number
+}
+
+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', 'GITHUB_TEST_CONNECTION_ID')
+  ? describe
+  : describe.skip
+
+suite('github 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, GITHUB_TEST_CONNECTION_ID } = env
+
+    const proxy = new IntegrationProxy({
+      managedOAuthBaseUrl: COMMANDABLE_MANAGED_OAUTH_BASE_URL,
+      managedOAuthSecretKey: COMMANDABLE_MANAGED_OAUTH_SECRET_KEY,
+    })
+    const integrationNode = { id: 'node-github', type: 'github', label: 'GitHub', connectionId: GITHUB_TEST_CONNECTION_ID } as any
+
+    const tools = loadIntegrationTools('github')
+    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>
+    }
+
+    // Discover owner/repo/issue for tests
+    const list_repos = buildHandler('list_repos')
+    const repos = await list_repos({})
+    const first = Array.isArray(repos) ? repos[0] : repos?.[0]
+    ctx.owner = first?.owner?.login || first?.owner || first?.full_name?.split?.('/')[0]
+    ctx.repo = first?.name || first?.full_name?.split?.('/')[1]
+
+    if (ctx.owner && ctx.repo) {
+      const list_issues = buildHandler('list_issues')
+      const issues = await list_issues({ owner: ctx.owner, repo: ctx.repo, state: 'all' })
+      const firstIssue = Array.isArray(issues) ? issues.find((i: any) => typeof i.number === 'number') : undefined
+      ctx.issue_number = firstIssue?.number
+    }
+  }, 60000)
+
+  it('list_repos returns repositories', async () => {
+    const handler = buildHandler('list_repos')
+    const result = await handler({})
+    expect(result).toBeTruthy()
+  }, 30000)
+
+  it('get_repo returns repo details', async () => {
+    if (!ctx.owner || !ctx.repo)
+      return expect(true).toBe(true)
+    const handler = buildHandler('get_repo')
+    const result = await handler({ owner: ctx.owner, repo: ctx.repo })
+    expect(result?.name?.toLowerCase?.()).toBe(ctx.repo?.toLowerCase?.())
+  }, 30000)
+
+  it('list_issues returns issues for repo', async () => {
+    if (!ctx.owner || !ctx.repo)
+      return expect(true).toBe(true)
+    const handler = buildHandler('list_issues')
+    const result = await handler({ owner: ctx.owner, repo: ctx.repo, state: 'all' })
+    expect(Array.isArray(result)).toBe(true)
+  }, 30000)
+
+  it('get_issue returns a single issue if available', async () => {
+    if (!ctx.owner || !ctx.repo || !ctx.issue_number)
+      return expect(true).toBe(true)
+    const handler = buildHandler('get_issue')
+    const result = await handler({ owner: ctx.owner, repo: ctx.repo, issue_number: ctx.issue_number })
+    expect(result?.number).toBe(ctx.issue_number)
+  }, 30000)
+
+  it('list_pull_requests returns PRs', async () => {
+    if (!ctx.owner || !ctx.repo)
+      return expect(true).toBe(true)
+    const handler = buildHandler('list_pull_requests')
+    const result = await handler({ owner: ctx.owner, repo: ctx.repo, state: 'all' })
+    expect(Array.isArray(result)).toBe(true)
+  }, 30000)
+
+  it('list_branches returns branches', async () => {
+    if (!ctx.owner || !ctx.repo)
+      return expect(true).toBe(true)
+    const handler = buildHandler('list_branches')
+    const result = await handler({ owner: ctx.owner, repo: ctx.repo })
+    expect(Array.isArray(result)).toBe(true)
+  }, 30000)
+
+  it('list_commits returns commits', async () => {
+    if (!ctx.owner || !ctx.repo)
+      return expect(true).toBe(true)
+    const handler = buildHandler('list_commits')
+    const result = await handler({ owner: ctx.owner, repo: ctx.repo })
+    expect(Array.isArray(result)).toBe(true)
+  }, 30000)
+})

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

@@ -0,0 +1,34 @@
+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, '\\$&')
+}
+
+describe('github static usage parity', () => {
+  it('every manifest tool is referenced in tests via build*(name)', () => {
+    const manifest = loadIntegrationManifest('github')!
+    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) {
+      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)
+    }
+
+    expect(missing, `Missing handler usages in tests: ${missing.join(', ')}`).toEqual([])
+  })
+})

package/integrations/github/__tests__/write_handlers.test.ts

@@ -0,0 +1,311 @@
+import { beforeAll, describe, expect, it } from 'vitest'
+import { IntegrationProxy } from '../../../src/integrations/proxy.js'
+import { loadIntegrationTools } from '../../../src/integrations/dataLoader.js'
+
+// LIVE GitHub write tests using managed OAuth
+// Required env vars for write tests:
+// - COMMANDABLE_MANAGED_OAUTH_BASE_URL
+// - COMMANDABLE_MANAGED_OAUTH_SECRET_KEY
+// - GITHUB_TEST_CONNECTION_ID (managed OAuth connection for provider 'github')
+// - GITHUB_TEST_OWNER (owner to use for write tests)
+// - GITHUB_TEST_REPO (repo to use for write tests)
+
+interface Ctx {
+  owner?: string
+  repo?: string
+  issue_number?: number
+}
+
+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',
+  'GITHUB_TEST_CONNECTION_ID',
+  'GITHUB_TEST_OWNER',
+  'GITHUB_TEST_REPO',
+)
+  ? describe
+  : describe.skip
+
+suite('github 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 {
+      COMMANDABLE_MANAGED_OAUTH_BASE_URL,
+      COMMANDABLE_MANAGED_OAUTH_SECRET_KEY,
+      GITHUB_TEST_CONNECTION_ID,
+      GITHUB_TEST_OWNER,
+      GITHUB_TEST_REPO,
+    } = env
+
+    const proxy = new IntegrationProxy({
+      managedOAuthBaseUrl: COMMANDABLE_MANAGED_OAUTH_BASE_URL,
+      managedOAuthSecretKey: COMMANDABLE_MANAGED_OAUTH_SECRET_KEY,
+    })
+    const integrationNode = { id: 'node-github', type: 'github', label: 'GitHub', connectionId: GITHUB_TEST_CONNECTION_ID } as any
+
+    const tools = loadIntegrationTools('github')
+    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>
+    }
+
+    ctx.owner = GITHUB_TEST_OWNER
+    ctx.repo = GITHUB_TEST_REPO
+  }, 60000)
+
+  it('create_issue -> update_issue -> comment_on_issue -> close_issue roundtrip', async () => {
+    if (!ctx.owner || !ctx.repo)
+      return expect(true).toBe(true)
+
+    const titleBase = `CmdTest Issue ${Date.now()}`
+
+    // Create
+    const create_issue = buildWriteHandler('create_issue')
+    const created = await create_issue({ owner: ctx.owner, repo: ctx.repo, title: titleBase, body: 'Initial body from test.' })
+    expect(created?.number).toBeTruthy()
+    ctx.issue_number = created.number
+
+    // Update
+    const update_issue = buildWriteHandler('update_issue')
+    const updated = await update_issue({ owner: ctx.owner, repo: ctx.repo, issue_number: ctx.issue_number, body: 'Updated body from test.' })
+    expect(updated?.number).toBe(ctx.issue_number)
+
+    // Comment
+    const comment_on_issue = buildWriteHandler('comment_on_issue')
+    const comment = await comment_on_issue({ owner: ctx.owner, repo: ctx.repo, issue_number: ctx.issue_number, body: 'A comment from test.' })
+    expect(comment?.id).toBeTruthy()
+
+    // Close
+    const close_issue = buildWriteHandler('close_issue')
+    const closed = await close_issue({ owner: ctx.owner, repo: ctx.repo, issue_number: ctx.issue_number })
+    expect(closed?.state).toBe('closed')
+  }, 90000)
+
+  it('create_repo -> delete_repo lifecycle', async () => {
+    if (!ctx.owner)
+      return expect(true).toBe(true)
+
+    const repoName = `cmdtest-repo-${Date.now()}`
+
+    // Create
+    const create_repo = buildWriteHandler('create_repo')
+    const created = await create_repo({
+      name: repoName,
+      description: 'Test repo created by integration tests',
+      private: true,
+      auto_init: true,
+    })
+    expect(created?.name).toBe(repoName)
+    expect(created?.full_name).toBe(`${ctx.owner}/${repoName}`)
+
+    // Delete
+    const delete_repo = buildWriteHandler('delete_repo')
+    const deleted = await delete_repo({ owner: ctx.owner, repo: repoName })
+    expect(deleted?.success).toBe(true)
+    expect(deleted?.status).toBe(204)
+  }, 90000)
+
+  it('create_or_update_file: single file commit', async () => {
+    if (!ctx.owner || !ctx.repo)
+      return expect(true).toBe(true)
+
+    const timestamp = Date.now()
+    const branchName = `test-single-file-${timestamp}`
+
+    // Create a new branch
+    const create_branch = buildWriteHandler('create_branch')
+    const branch = await create_branch({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      branch: branchName,
+    })
+    expect(branch?.ref).toBe(`refs/heads/${branchName}`)
+
+    // Create a file using create_or_update_file
+    const create_or_update_file = buildWriteHandler('create_or_update_file')
+    const file = await create_or_update_file({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      path: `test-single-${timestamp}.txt`,
+      message: `Add single test file ${timestamp}`,
+      content: `Test content with UTF-8: Hello 世界 🌍\nCreated at ${timestamp}`,
+      branch: branchName,
+    })
+    expect(file?.commit?.message).toBe(`Add single test file ${timestamp}`)
+    expect(file?.content?.path).toBe(`test-single-${timestamp}.txt`)
+    
+    // Update the same file
+    const updated = await create_or_update_file({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      path: `test-single-${timestamp}.txt`,
+      message: `Update test file ${timestamp}`,
+      content: `Updated content at ${timestamp}`,
+      branch: branchName,
+      sha: file.content.sha,
+    })
+    expect(updated?.commit?.message).toBe(`Update test file ${timestamp}`)
+  }, 90000)
+
+  it('create_commit: multiple files in one commit', async () => {
+    if (!ctx.owner || !ctx.repo)
+      return expect(true).toBe(true)
+
+    const timestamp = Date.now()
+    const branchName = `test-multi-file-${timestamp}`
+
+    // Create a new branch
+    const create_branch = buildWriteHandler('create_branch')
+    const branch = await create_branch({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      branch: branchName,
+    })
+    expect(branch?.ref).toBe(`refs/heads/${branchName}`)
+
+    // Create multiple files in one commit using create_commit
+    const create_commit = buildWriteHandler('create_commit')
+    const commit = await create_commit({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      branch: branchName,
+      message: `Add multiple files ${timestamp}`,
+      files: [
+        {
+          path: `multi-test/file1-${timestamp}.txt`,
+          content: 'Content of file 1',
+        },
+        {
+          path: `multi-test/file2-${timestamp}.txt`,
+          content: 'Content of file 2',
+        },
+        {
+          path: `multi-test/file3-${timestamp}.md`,
+          content: '# Test File 3\n\nWith UTF-8: 你好 🚀',
+        },
+      ],
+    })
+    expect(commit?.commit?.sha).toBeTruthy()
+    expect(commit?.commit?.message).toBe(`Add multiple files ${timestamp}`)
+    expect(commit?.files?.length).toBe(3)
+
+    // Update and delete files in another commit
+    const commit2 = await create_commit({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      branch: branchName,
+      message: `Update and delete files ${timestamp}`,
+      files: [
+        {
+          path: `multi-test/file1-${timestamp}.txt`,
+          content: 'Updated content of file 1',
+        },
+        {
+          path: `multi-test/file2-${timestamp}.txt`,
+          // Omit content to delete the file
+        },
+        {
+          path: `multi-test/file4-${timestamp}.txt`,
+          content: 'New file 4',
+        },
+      ],
+    })
+    expect(commit2?.commit?.sha).toBeTruthy()
+    expect(commit2?.commit?.message).toBe(`Update and delete files ${timestamp}`)
+  }, 120000)
+
+  it('full PR workflow: create_branch -> create_commit -> create_pull_request -> merge_pull_request', async () => {
+    if (!ctx.owner || !ctx.repo)
+      return expect(true).toBe(true)
+
+    const timestamp = Date.now()
+    const branchName = `test-pr-workflow-${timestamp}`
+
+    // Create a new branch
+    const create_branch = buildWriteHandler('create_branch')
+    const branch = await create_branch({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      branch: branchName,
+    })
+    expect(branch?.ref).toBe(`refs/heads/${branchName}`)
+
+    // Create multiple files using create_commit
+    const create_commit = buildWriteHandler('create_commit')
+    const commit = await create_commit({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      branch: branchName,
+      message: `Add feature files ${timestamp}`,
+      files: [
+        {
+          path: `feature-${timestamp}/index.js`,
+          content: 'export default function() { return "Hello"; }',
+        },
+        {
+          path: `feature-${timestamp}/README.md`,
+          content: `# Feature ${timestamp}\n\nThis is a test feature.`,
+        },
+      ],
+    })
+    expect(commit?.commit?.sha).toBeTruthy()
+
+    // Create a pull request
+    const create_pull_request = buildWriteHandler('create_pull_request')
+    const get_repo = buildReadHandler('get_repo')
+    const repoDetails = await get_repo({ owner: ctx.owner, repo: ctx.repo })
+    const defaultBranch = repoDetails?.default_branch || 'main'
+    const pr = await create_pull_request({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      title: `Test PR workflow ${timestamp}`,
+      body: 'This PR was created by integration tests to test the full workflow',
+      head: branchName,
+      base: defaultBranch,
+    })
+    expect(pr?.number).toBeTruthy()
+    const prNumber = pr.number
+
+    // Add labels to the PR
+    const add_labels_to_issue = buildWriteHandler('add_labels_to_issue')
+    try {
+      await add_labels_to_issue({
+        owner: ctx.owner,
+        repo: ctx.repo,
+        issue_number: prNumber,
+        labels: ['test'],
+      })
+    } catch (e) {
+      // Label might not exist, that's ok for this test
+      console.log('Label add skipped (label may not exist)')
+    }
+
+    // Merge the pull request
+    const merge_pull_request = buildWriteHandler('merge_pull_request')
+    const merged = await merge_pull_request({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      pull_number: prNumber,
+      merge_method: 'squash',
+    })
+    expect(merged?.merged).toBe(true)
+  }, 150000)
+})

package/integrations/github/credentials.json

@@ -0,0 +1,20 @@
+{
+  "schema": {
+    "type": "object",
+    "properties": {
+      "token": {
+        "type": "string",
+        "title": "Personal Access Token",
+        "description": "GitHub personal access token (classic or fine-grained) with appropriate scopes."
+      }
+    },
+    "required": ["token"],
+    "additionalProperties": false
+  },
+  "injection": {
+    "headers": {
+      "Authorization": "Bearer {{token}}"
+    }
+  }
+}
+

package/integrations/github/credentials_hint.md

@@ -0,0 +1,7 @@
+Create a GitHub personal access token and paste it here.
+
+- Fine-grained PAT: Settings → Developer settings → Personal access tokens → Fine-grained tokens
+- Classic PAT: Settings → Developer settings → Personal access tokens → Tokens (classic)
+
+Minimum scopes depend on the tools you use (repo read/write, issues, pull requests, etc.).
+

package/integrations/github/handlers/add_labels_to_issue.js

@@ -0,0 +1,12 @@
+async (input) => {
+  const body = {
+    labels: input.labels,
+  }
+  
+  const res = await integration.fetch(`/repos/${input.owner}/${input.repo}/issues/${input.issue_number}/labels`, { 
+    method: 'POST', 
+    body 
+  })
+  return await res.json()
+}
+

package/integrations/github/handlers/close_issue.js

@@ -0,0 +1,5 @@
+async (input) => {
+  const body = { state: 'closed' }
+  const res = await integration.fetch(`/repos/${input.owner}/${input.repo}/issues/${input.issue_number}`, { method: 'PATCH', body })
+  return await res.json()
+}

package/integrations/github/handlers/comment_on_issue.js

@@ -0,0 +1,5 @@
+async (input) => {
+  const body = { body: input.body }
+  const res = await integration.fetch(`/repos/${input.owner}/${input.repo}/issues/${input.issue_number}/comments`, { method: 'POST', body })
+  return await res.json()
+}

package/integrations/github/handlers/create_branch.js

@@ -0,0 +1,33 @@
+async (input) => {
+  // First, get the SHA of the branch to create from
+  let fromRef = input.from_branch || 'main'
+  
+  // Try to get the ref, fallback to master if main doesn't exist
+  let refRes
+  try {
+    refRes = await integration.fetch(`/repos/${input.owner}/${input.repo}/git/refs/heads/${fromRef}`)
+  } catch (e) {
+    if (fromRef === 'main') {
+      fromRef = 'master'
+      refRes = await integration.fetch(`/repos/${input.owner}/${input.repo}/git/refs/heads/${fromRef}`)
+    } else {
+      throw e
+    }
+  }
+  
+  const refData = await refRes.json()
+  const sha = refData.object.sha
+  
+  // Create the new branch
+  const body = {
+    ref: `refs/heads/${input.branch}`,
+    sha: sha,
+  }
+  
+  const res = await integration.fetch(`/repos/${input.owner}/${input.repo}/git/refs`, { 
+    method: 'POST', 
+    body 
+  })
+  return await res.json()
+}
+

package/integrations/github/handlers/create_commit.js

@@ -0,0 +1,91 @@
+async (input) => {
+  const { owner, repo, branch, message, files } = input
+  
+  // 1. Get the current commit SHA for the branch
+  const refRes = await integration.fetch(`/repos/${owner}/${repo}/git/refs/heads/${branch}`)
+  const refData = await refRes.json()
+  const currentCommitSha = refData.object.sha
+  
+  // 2. Get the current commit to get its tree
+  const commitRes = await integration.fetch(`/repos/${owner}/${repo}/git/commits/${currentCommitSha}`)
+  const commitData = await commitRes.json()
+  const currentTreeSha = commitData.tree.sha
+  
+  // 3. Create blobs for each file with content
+  const tree = []
+  for (const file of files) {
+    if (file.content !== undefined && file.content !== null) {
+      // Create a blob for this file
+      const contentBase64 = typeof Buffer !== 'undefined'
+        ? Buffer.from(file.content).toString('base64')
+        : btoa(unescape(encodeURIComponent(file.content)))
+      
+      const blobRes = await integration.fetch(`/repos/${owner}/${repo}/git/blobs`, {
+        method: 'POST',
+        body: {
+          content: contentBase64,
+          encoding: 'base64',
+        },
+      })
+      const blobData = await blobRes.json()
+      
+      tree.push({
+        path: file.path,
+        mode: file.mode || '100644',
+        type: 'blob',
+        sha: blobData.sha,
+      })
+    } else {
+      // File deletion (null sha means delete)
+      tree.push({
+        path: file.path,
+        mode: '100644',
+        type: 'blob',
+        sha: null,
+      })
+    }
+  }
+  
+  // 4. Create a new tree
+  const treeRes = await integration.fetch(`/repos/${owner}/${repo}/git/trees`, {
+    method: 'POST',
+    body: {
+      base_tree: currentTreeSha,
+      tree: tree,
+    },
+  })
+  const treeData = await treeRes.json()
+  
+  // 5. Create the commit
+  const newCommitRes = await integration.fetch(`/repos/${owner}/${repo}/git/commits`, {
+    method: 'POST',
+    body: {
+      message: message,
+      tree: treeData.sha,
+      parents: [currentCommitSha],
+    },
+  })
+  const newCommitData = await newCommitRes.json()
+  
+  // 6. Update the branch reference
+  const updateRefRes = await integration.fetch(`/repos/${owner}/${repo}/git/refs/heads/${branch}`, {
+    method: 'PATCH',
+    body: {
+      sha: newCommitData.sha,
+    },
+  })
+  await updateRefRes.json()
+  
+  return {
+    commit: {
+      sha: newCommitData.sha,
+      url: newCommitData.html_url,
+      message: newCommitData.message,
+    },
+    tree: {
+      sha: treeData.sha,
+    },
+    files: files.map(f => ({ path: f.path })),
+  }
+}
+

package/integrations/github/handlers/create_issue.js

@@ -0,0 +1,10 @@
+async (input) => {
+  const body = {
+    title: input.title,
+    body: input.body,
+    assignees: input.assignees,
+    labels: input.labels,
+  }
+  const res = await integration.fetch(`/repos/${input.owner}/${input.repo}/issues`, { method: 'POST', body })
+  return await res.json()
+}

package/integrations/github/handlers/create_or_update_file.js

@@ -0,0 +1,21 @@
+async (input) => {
+  // GitHub API expects content to be base64 encoded
+  // Use btoa with proper UTF-8 encoding for browser/Node.js compatibility
+  const contentBase64 = typeof Buffer !== 'undefined' 
+    ? Buffer.from(input.content).toString('base64')
+    : btoa(unescape(encodeURIComponent(input.content)))
+  
+  const body = {
+    message: input.message,
+    content: contentBase64,
+    branch: input.branch,
+    sha: input.sha,
+  }
+  
+  const res = await integration.fetch(`/repos/${input.owner}/${input.repo}/contents/${input.path}`, { 
+    method: 'PUT', 
+    body 
+  })
+  return await res.json()
+}
+