Create index.js

index.js

@@ -0,0 +1,293 @@
+const express = require('express');
+const { WebSocketServer } = require('ws');
+const { Octokit } = require('@octokit/rest');
+const http = require('http');
+
+const CONFIG = {
+  GITHUB_TOKEN: process.env.GITHUB_TOKEN || 'ghp_your_github_token_here',
+  REPOS_TO_WATCH: [
+    { owner: process.env.REPO_OWNER || 'herzonly', repo: process.env.REPO_NAME || 'DHX' },
+  ],
+  POLL_INTERVAL: 30000,
+  BUFFER_TIME: 5 * 60 * 1000,
+  PORT: process.env.PORT || 7860
+};
+
+const octokit = new Octokit({
+  auth: CONFIG.GITHUB_TOKEN
+});
+
+const app = express();
+const server = http.createServer(app);
+const wss = new WebSocketServer({ server });
+
+app.use((req, res, next) => {
+  const allowedMethods = ['GET', 'OPTIONS'];
+  
+  if (!allowedMethods.includes(req.method)) {
+    console.log(`[BLOCKED] ${req.method} request from ${req.ip} to ${req.path}`);
+    return res.status(405).json({ 
+      error: 'Method Not Allowed',
+      message: 'Only GET requests are allowed',
+      allowed_methods: allowedMethods
+    });
+  }
+  
+  next();
+});
+
+const changedFilesBuffer = [];
+const cleanupTimers = new Map();
+const lastCommits = new Map();
+const clients = new Set();
+
+wss.on('connection', (ws) => {
+  console.log('New WebSocket client connected');
+  clients.add(ws);
+
+  ws.send(JSON.stringify({
+    type: 'initial',
+    count: changedFilesBuffer.length,
+    data: changedFilesBuffer
+  }));
+
+  ws.on('close', () => {
+    console.log('Client disconnected');
+    clients.delete(ws);
+  });
+
+  ws.on('error', (error) => {
+    console.error('WebSocket error:', error);
+    clients.delete(ws);
+  });
+});
+
+function broadcast(data) {
+  const message = JSON.stringify(data);
+  clients.forEach((client) => {
+    if (client.readyState === 1) {
+      client.send(message);
+    }
+  });
+}
+
+async function getFileContent(owner, repo, path, ref) {
+  try {
+    const { data } = await octokit.repos.getContent({
+      owner,
+      repo,
+      path,
+      ref
+    });
+
+    if (data.content) {
+      return Buffer.from(data.content, 'base64').toString('utf-8');
+    }
+    return null;
+  } catch (error) {
+    console.error(`Error getting file content for ${path}:`, error.message);
+    return null;
+  }
+}
+
+function addChangedFile(fileData) {
+  const id = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  
+  const item = {
+    id,
+    ...fileData,
+    created_at: new Date().toISOString()
+  };
+
+  changedFilesBuffer.push(item);
+  
+  console.log(`[BUFFER] Added file: ${fileData.changed_file.name} (Total: ${changedFilesBuffer.length})`);
+  
+  const timer = setTimeout(() => {
+    const index = changedFilesBuffer.findIndex(f => f.id === id);
+    if (index !== -1) {
+      const removed = changedFilesBuffer.splice(index, 1)[0];
+      console.log(`[CLEANUP] Removed: ${removed.changed_file.name} after 5 minutes (Remaining: ${changedFilesBuffer.length})`);
+      
+      broadcast({
+        type: 'cleanup',
+        id: id,
+        filename: removed.changed_file.name,
+        remaining_count: changedFilesBuffer.length
+      });
+    }
+    cleanupTimers.delete(id);
+  }, CONFIG.BUFFER_TIME);
+
+  cleanupTimers.set(id, timer);
+
+  return item;
+}
+
+async function checkRepoChanges(owner, repo) {
+  try {
+    const { data: commits } = await octokit.repos.listCommits({
+      owner,
+      repo,
+      per_page: 10
+    });
+
+    if (commits.length === 0) return;
+
+    const repoKey = `${owner}/${repo}`;
+    const lastCommitSha = lastCommits.get(repoKey);
+    
+    if (!lastCommitSha) {
+      lastCommits.set(repoKey, commits[0].sha);
+      console.log(`[INIT] Tracking ${repoKey} from commit: ${commits[0].sha.substring(0, 7)}`);
+      return;
+    }
+
+    const newCommits = [];
+    for (const commit of commits) {
+      if (commit.sha === lastCommitSha) break;
+      newCommits.push(commit);
+    }
+
+    if (newCommits.length === 0) return;
+
+    console.log(`[DETECTED] ${newCommits.length} new commit(s) in ${repoKey}`);
+
+    for (const commit of newCommits.reverse()) {
+      try {
+        const { data: commitDetail } = await octokit.repos.getCommit({
+          owner,
+          repo,
+          ref: commit.sha
+        });
+
+        console.log(`[COMMIT] ${commit.sha.substring(0, 7)}: "${commit.commit.message}" - ${commitDetail.files.length} file(s)`);
+
+        for (const file of commitDetail.files) {
+          if (file.status === 'removed') {
+            console.log(`  [SKIP] ${file.filename} (removed)`);
+            continue;
+          }
+
+          console.log(`  [PROCESS] ${file.filename} (${file.status})`);
+
+          const content = await getFileContent(owner, repo, file.filename, commit.sha);
+
+          const fileChangeData = {
+            repository: repoKey,
+            commit: {
+              sha: commit.sha,
+              short_sha: commit.sha.substring(0, 7),
+              message: commit.commit.message,
+              author: commit.commit.author.name,
+              email: commit.commit.author.email,
+              date: commit.commit.author.date,
+              url: commit.html_url
+            },
+            changed_file: {
+              name: file.filename,
+              status: file.status,
+              additions: file.additions,
+              deletions: file.deletions,
+              changes: file.changes,
+              isinya: content || 'Unable to fetch content',
+              patch: file.patch || null
+            }
+          };
+
+          const bufferedItem = addChangedFile(fileChangeData);
+
+          broadcast({
+            type: 'new_change',
+            data: bufferedItem,
+            total_count: changedFilesBuffer.length
+          });
+        }
+
+      } catch (error) {
+        console.error(`[ERROR] Processing commit ${commit.sha.substring(0, 7)}:`, error.message);
+      }
+    }
+
+    lastCommits.set(repoKey, commits[0].sha);
+
+  } catch (error) {
+    console.error(`[ERROR] Checking repo ${owner}/${repo}:`, error.message);
+  }
+}
+
+app.get('/', (req, res) => {
+  res.json({
+    name: 'GitHub Repository Watcher',
+    version: '1.0.0',
+    endpoints: {
+      data: '/data',
+      health: '/health'
+    },
+    websocket: 'Connect to same URL with ws:// or wss://'
+  });
+});
+
+app.get('/data', (req, res) => {
+  res.json({
+    success: true,
+    count: changedFilesBuffer.length,
+    data: changedFilesBuffer,
+    timestamp: new Date().toISOString()
+  });
+});
+
+app.get('/health', (req, res) => {
+  res.json({ 
+    status: 'running',
+    buffered_files: changedFilesBuffer.length,
+    ws_clients: clients.size,
+    watching_repos: CONFIG.REPOS_TO_WATCH.length,
+    poll_interval_sec: CONFIG.POLL_INTERVAL / 1000
+  });
+});
+
+server.listen(CONFIG.PORT, () => {
+  console.log(`\n${'='.repeat(60)}`);
+  console.log(`  GitHub Repository Watcher - Running`);
+  console.log(`${'='.repeat(60)}`);
+  console.log(`  Server:         http://localhost:${CONFIG.PORT}`);
+  console.log(`  WebSocket:      ws://localhost:${CONFIG.PORT}`);
+  console.log(`  Data Endpoint:  http://localhost:${CONFIG.PORT}/data`);
+  console.log(`${'='.repeat(60)}`);
+  console.log(`  Watching ${CONFIG.REPOS_TO_WATCH.length} repo(s):`);
+  CONFIG.REPOS_TO_WATCH.forEach(r => {
+    console.log(`    - ${r.owner}/${r.repo}`);
+  });
+  console.log(`  Poll Interval:  ${CONFIG.POLL_INTERVAL / 1000}s`);
+  console.log(`  Buffer Time:    ${CONFIG.BUFFER_TIME / 1000 / 60}min`);
+  console.log(`${'='.repeat(60)}\n`);
+});
+
+async function startWatching() {
+  console.log('[START] Initializing repository watcher...\n');
+
+  for (const { owner, repo } of CONFIG.REPOS_TO_WATCH) {
+    await checkRepoChanges(owner, repo);
+  }
+
+  setInterval(async () => {
+    for (const { owner, repo } of CONFIG.REPOS_TO_WATCH) {
+      await checkRepoChanges(owner, repo);
+    }
+  }, CONFIG.POLL_INTERVAL);
+}
+
+startWatching();
+
+process.on('SIGINT', () => {
+  console.log('\n[SHUTDOWN] Cleaning up...');
+  
+  cleanupTimers.forEach(timer => clearTimeout(timer));
+  cleanupTimers.clear();
+  
+  wss.close();
+  server.close();
+  console.log('[SHUTDOWN] Server stopped');
+  process.exit(0);
+});