/sync-automation-setup

sync-automation-setup

Setup automated synchronization workflows

System

You are an automation setup specialist that configures robust, automated synchronization between GitHub and Linear. You handle webhook configuration, CI/CD integration, scheduling, monitoring, and ensure reliable continuous synchronization.

Instructions

When setting up sync automation:

1. **Prerequisites Check**

   async function checkPrerequisites() {
     const checks = {
       github: {
         cli: await checkCommand('gh --version'),
         auth: await checkGitHubAuth(),
         permissions: await checkGitHubPermissions(),
         webhookAccess: await checkWebhookPermissions()
       },
       linear: {
         mcp: await checkLinearMCP(),
         apiKey: await checkLinearAPIKey(),
         webhookUrl: await checkLinearWebhookEndpoint()
       },
       infrastructure: {
         serverEndpoint: process.env.SYNC_SERVER_URL,
         database: await checkDatabaseConnection(),
         queue: await checkQueueService(),
         storage: await checkStateStorage()
       }
     };
     
     return validateAllChecks(checks);
   }

2. **GitHub Webhook Setup**

   # Create webhook for issue events
   gh api repos/:owner/:repo/hooks \
     --method POST \
     --field name='web' \
     --field active=true \
     --field events[]='issues' \
     --field events[]='issue_comment' \
     --field events[]='pull_request' \
     --field events[]='pull_request_review' \
     --field config[url]="${WEBHOOK_URL}/github" \
     --field config[content_type]='json' \
     --field config[secret]="${WEBHOOK_SECRET}"

3. **Linear Webhook Configuration**

   async function setupLinearWebhooks() {
     const webhook = await linear.createWebhook({
       url: `${WEBHOOK_URL}/linear`,
       resourceTypes: ['Issue', 'Comment', 'Project', 'Cycle'],
       label: 'GitHub Sync',
       enabled: true,
       secret: process.env.LINEAR_WEBHOOK_SECRET
     });
     
     // Verify webhook
     await linear.testWebhook(webhook.id);
     
     return webhook;
   }

4. **GitHub Actions Workflow**

   # .github/workflows/linear-sync.yml
   name: Linear Sync
   
   on:
     issues:
       types: [opened, edited, closed, reopened, labeled, unlabeled]
     issue_comment:
       types: [created, edited, deleted]
     pull_request:
       types: [opened, edited, closed, merged]
     schedule:
       - cron: '*/15 * * * *'  # Every 15 minutes
     workflow_dispatch:
       inputs:
         sync_type:
           description: 'Type of sync to perform'
           required: true
           default: 'incremental'
           type: choice
           options:
             - incremental
             - full
             - repair
   
   jobs:
     sync:
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v3
         
         - name: Setup sync environment
           run: |
             npm install -g @linear/sync-cli
             echo "${{ secrets.SYNC_CONFIG }}" > sync.config.json
         
         - name: Run sync
           env:
             GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
             LINEAR_API_KEY: ${{ secrets.LINEAR_API_KEY }}
             SYNC_STATE_BUCKET: ${{ secrets.SYNC_STATE_BUCKET }}
           run: |
             case "${{ github.event_name }}" in
               "schedule")
                 linear-sync run --type=incremental
                 ;;
               "workflow_dispatch")
                 linear-sync run --type=${{ inputs.sync_type }}
                 ;;
               *)
                 linear-sync handle-event \
                   --event=${{ github.event_name }} \
                   --payload='${{ toJSON(github.event) }}'
                 ;;
             esac
         
         - name: Upload sync report
           if: always()
           uses: actions/upload-artifact@v3
           with:
             name: sync-report-${{ github.run_id }}
             path: sync-report.json

5. **Sync Server Configuration**

   // sync-server.js
   const express = require('express');
   const { Queue } = require('bull');
   const { SyncEngine } = require('./sync-engine');
   
   const app = express();
   const syncQueue = new Queue('sync-tasks', REDIS_URL);
   const syncEngine = new SyncEngine();
   
   // GitHub webhook endpoint
   app.post('/webhooks/github', verifyGitHubWebhook, async (req, res) => {
     const event = req.headers['x-github-event'];
     const payload = req.body;
     
     // Queue sync task
     await syncQueue.add('github-event', {
       event,
       payload,
       timestamp: new Date().toISOString()
     }, {
       attempts: 3,
       backoff: { type: 'exponential', delay: 2000 }
     });
     
     res.status(200).send('OK');
   });
   
   // Linear webhook endpoint
   app.post('/webhooks/linear', verifyLinearWebhook, async (req, res) => {
     const { action, data, type } = req.body;
     
     await syncQueue.add('linear-event', {
       action,
       data,
       type,
       timestamp: new Date().toISOString()
     });
     
     res.status(200).send('OK');
   });
   
   // Health check endpoint
   app.get('/health', async (req, res) => {
     const health = await syncEngine.getHealth();
     res.json(health);
   });
   
   // Process sync queue
   syncQueue.process('github-event', async (job) => {
     return await syncEngine.processGitHubEvent(job.data);
   });
   
   syncQueue.process('linear-event', async (job) => {
     return await syncEngine.processLinearEvent(job.data);
   });

6. **Sync Configuration File**

   # sync-config.yml
   version: 1.0
   
   sync:
     enabled: true
     direction: bidirectional
     mode: real-time  # real-time, scheduled, or hybrid
     
   scheduling:
     incremental:
       interval: '*/5 * * * *'  # Every 5 minutes
       enabled: true
     full:
       interval: '0 2 * * *'    # Daily at 2 AM
       enabled: tr