Upload server.js

server.js

@@ -0,0 +1,417 @@
+import express from "express";
+import dotenv from "dotenv";
+import axios from "axios";
+import { Buffer } from "buffer";
+
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 7860;
+
+app.use(express.json({ limit: "10mb" }));
+app.use(express.urlencoded({ extended: true }));
+
+// GitHub Configuration
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN || "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";
+const GITHUB_OWNER = process.env.GITHUB_OWNER || "Atlastech45";
+const GITHUB_REPO = process.env.GITHUB_REPO || "Session_4";
+const GITHUB_BRANCH = process.env.GITHUB_BRANCH || "main";
+
+// GitHub API base URL
+const GITHUB_API = "https://api.github.com";
+const BASE_PATH = "sessions"; // Folder where sessions will be stored
+
+// Create axios instance with auth headers
+const githubApi = axios.create({
+  baseURL: GITHUB_API,
+  headers: {
+    Authorization: `token ${GITHUB_TOKEN}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "Session_4"
+  }
+});
+
+// Helper: Check if file exists in GitHub
+async function fileExists(sessionId, filename) {
+  try {
+    const path = `${BASE_PATH}/session_${sessionId}/${filename}`;
+    const response = await githubApi.get(`/repos/${GITHUB_OWNER}/${GITHUB_REPO}/contents/${path}`, {
+      params: { ref: GITHUB_BRANCH }
+    });
+    return { exists: true, sha: response.data.sha };
+  } catch (error) {
+    if (error.response?.status === 404) {
+      return { exists: false, sha: null };
+    }
+    throw error;
+  }
+}
+
+// Helper: Upload file to GitHub
+async function uploadToGitHub(sessionId, filename, content, sha = null) {
+  try {
+    const path = `${BASE_PATH}/session_${sessionId}/${filename}`;
+    const message = sha ? `Update ${filename} for session ${sessionId}` : `Create ${filename} for session ${sessionId}`;
+    
+    const payload = {
+      message,
+      content: Buffer.from(JSON.stringify(content, null, 2)).toString("base64"),
+      branch: GITHUB_BRANCH
+    };
+
+    if (sha) {
+      payload.sha = sha;
+    }
+
+    const response = await githubApi.put(
+      `/repos/${GITHUB_OWNER}/${GITHUB_REPO}/contents/${path}`,
+      payload
+    );
+
+    return response.data;
+  } catch (error) {
+    console.error(`GitHub upload error for ${filename}:`, error.response?.data || error.message);
+    throw error;
+  }
+}
+
+// Helper: Download file from GitHub
+async function downloadFromGitHub(sessionId, filename) {
+  try {
+    const path = `${BASE_PATH}/session_${sessionId}/${filename}`;
+    const response = await githubApi.get(`/repos/${GITHUB_OWNER}/${GITHUB_REPO}/contents/${path}`, {
+      params: { ref: GITHUB_BRANCH }
+    });
+    
+    const content = Buffer.from(response.data.content, "base64").toString("utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.response?.status === 404) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+// Helper: Delete file from GitHub
+async function deleteFromGitHub(sessionId, filename) {
+  try {
+    const fileInfo = await fileExists(sessionId, filename);
+    if (!fileInfo.exists) {
+      return false;
+    }
+
+    const path = `${BASE_PATH}/session_${sessionId}/${filename}`;
+    await githubApi.delete(`/repos/${GITHUB_OWNER}/${GITHUB_REPO}/contents/${path}`, {
+      data: {
+        message: `Delete ${filename} for session ${sessionId}`,
+        sha: fileInfo.sha,
+        branch: GITHUB_BRANCH
+      }
+    });
+
+    return true;
+  } catch (error) {
+    console.error(`GitHub delete error for ${filename}:`, error.response?.data || error.message);
+    throw error;
+  }
+}
+
+// Helper: List all sessions
+async function listSessions() {
+  try {
+    // First, check if sessions folder exists
+    try {
+      const response = await githubApi.get(`/repos/${GITHUB_OWNER}/${GITHUB_REPO}/contents/${BASE_PATH}`, {
+        params: { ref: GITHUB_BRANCH }
+      });
+      
+      const sessions = response.data
+        .filter(item => item.type === "dir" && item.name.startsWith("session_"))
+        .map(item => item.name.replace("session_", ""));
+      
+      return sessions;
+    } catch (error) {
+      if (error.response?.status === 404) {
+        // Sessions folder doesn't exist yet
+        return [];
+      }
+      throw error;
+    }
+  } catch (error) {
+    console.error("List sessions error:", error);
+    throw error;
+  }
+}
+
+// -------------------- ROUTES -------------------- //
+
+// Health check
+app.get("/ping", (req, res) => res.json({ 
+  status: "ok", 
+  storage: "GitHub",
+  repo: `${GITHUB_OWNER}/${GITHUB_REPO}`
+}));
+
+// Upload/Update session with both creds and settings
+app.post("/upload", async (req, res) => {
+  try {
+    const { sessionId, creds, settings } = req.body;
+    if (!sessionId || !creds) {
+      return res.status(400).json({ error: "sessionId and creds are required" });
+    }
+
+    // Check if creds.json exists
+    const credsInfo = await fileExists(sessionId, "creds.json");
+    
+    // Upload/Update creds.json
+    await uploadToGitHub(sessionId, "creds.json", creds, credsInfo.sha);
+
+    // Upload/Update settings.json
+    const settingsToSave = settings || getDefaultSettings();
+    const settingsInfo = await fileExists(sessionId, "settings.json");
+    await uploadToGitHub(sessionId, "settings.json", settingsToSave, settingsInfo.sha);
+
+    console.log(`✅ ${credsInfo.exists ? 'Updated' : 'Created'} session ${sessionId} in GitHub`);
+    res.json({ 
+      success: true, 
+      message: `Session ${sessionId} ${credsInfo.exists ? 'updated' : 'created'}.`,
+      timestamp: new Date().toISOString(),
+      storage: "github",
+      repo: `${GITHUB_OWNER}/${GITHUB_REPO}`
+    });
+  } catch (err) {
+    console.error("Upload error:", err);
+    res.status(500).json({ error: "Failed to upload session", details: err.message });
+  }
+});
+
+// Update session (explicit overwrite)
+app.put("/session/:id", async (req, res) => {
+  try {
+    const sessionId = req.params.id;
+    const { creds, settings } = req.body;
+
+    if (!creds) {
+      return res.status(400).json({ error: "creds are required" });
+    }
+
+    // Check if session exists
+    const credsInfo = await fileExists(sessionId, "creds.json");
+    if (!credsInfo.exists) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+
+    // Force update creds.json
+    await uploadToGitHub(sessionId, "creds.json", creds, credsInfo.sha);
+
+    // Force update settings.json
+    const settingsToSave = settings || getDefaultSettings();
+    const settingsInfo = await fileExists(sessionId, "settings.json");
+    await uploadToGitHub(sessionId, "settings.json", settingsToSave, settingsInfo.exists ? settingsInfo.sha : null);
+
+    console.log(`🔄 Force-updated session ${sessionId} in GitHub`);
+    res.json({ 
+      success: true, 
+      message: `Session ${sessionId} force-updated.`,
+      timestamp: new Date().toISOString()
+    });
+  } catch (err) {
+    console.error("Update error:", err);
+    res.status(500).json({ error: "Failed to update session", details: err.message });
+  }
+});
+
+// Download session with both creds and settings
+app.get("/session/:id", async (req, res) => {
+  try {
+    const sessionId = req.params.id;
+    const files = {};
+
+    // Download creds.json
+    const creds = await downloadFromGitHub(sessionId, "creds.json");
+    if (!creds) {
+      return res.status(404).json({ error: "Session creds not found" });
+    }
+    files["creds.json"] = creds;
+
+    // Download settings.json if exists
+    const settings = await downloadFromGitHub(sessionId, "settings.json");
+    files["settings.json"] = settings || getDefaultSettings();
+
+    res.json({ 
+      sessionId, 
+      files,
+      storage: "github",
+      repo: `${GITHUB_OWNER}/${GITHUB_REPO}`
+    });
+  } catch (err) {
+    console.error("Download error:", err);
+    res.status(404).json({ error: "Session not found", details: err.message });
+  }
+});
+
+// Delete session (both creds and settings)
+app.delete("/session/:id", async (req, res) => {
+  try {
+    const sessionId = req.params.id;
+
+    // Delete both files
+    const credsDeleted = await deleteFromGitHub(sessionId, "creds.json");
+    const settingsDeleted = await deleteFromGitHub(sessionId, "settings.json");
+
+    if (!credsDeleted && !settingsDeleted) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+
+    console.log(`🗑 Deleted session ${sessionId} from GitHub`);
+    res.json({ 
+      success: true, 
+      message: `Session ${sessionId} deleted.`,
+      credsDeleted,
+      settingsDeleted
+    });
+  } catch (err) {
+    console.error("Delete error:", err);
+    res.status(500).json({ error: "Failed to delete session", details: err.message });
+  }
+});
+
+// List all sessions
+app.get("/sessions", async (req, res) => {
+  try {
+    const sessions = await listSessions();
+    res.json({ 
+      sessions,
+      count: sessions.length,
+      storage: "github",
+      repo: `${GITHUB_OWNER}/${GITHUB_REPO}`
+    });
+  } catch (err) {
+    console.error("List sessions error:", err);
+    res.status(500).json({ error: "Failed to list sessions", details: err.message });
+  }
+});
+
+// Get session info
+app.get("/session/:id/info", async (req, res) => {
+  try {
+    const sessionId = req.params.id;
+    
+    // Check if session exists
+    const credsInfo = await fileExists(sessionId, "creds.json");
+    if (!credsInfo.exists) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+
+    // Get commit history for the session folder
+    try {
+      const response = await githubApi.get(`/repos/${GITHUB_OWNER}/${GITHUB_REPO}/commits`, {
+        params: {
+          path: `${BASE_PATH}/session_${sessionId}`,
+          per_page: 1
+        }
+      });
+
+      if (response.data.length > 0) {
+        const lastCommit = response.data[0];
+        res.json({ 
+          sessionId, 
+          lastModified: lastCommit.commit.committer.date,
+          author: lastCommit.commit.author.name,
+          message: lastCommit.commit.message,
+          storage: "github"
+        });
+      } else {
+        res.json({ 
+          sessionId, 
+          message: "No commit history found",
+          storage: "github"
+        });
+      }
+    } catch (commitError) {
+      res.json({ 
+        sessionId, 
+        message: "Session exists but no commit info available",
+        storage: "github"
+      });
+    }
+  } catch (err) {
+    console.error("Session info error:", err);
+    res.status(500).json({ error: "Failed to get session info", details: err.message });
+  }
+});
+
+// Test GitHub connection
+app.get("/github-test", async (req, res) => {
+  try {
+    // Test repository access
+    const repoResponse = await githubApi.get(`/repos/${GITHUB_OWNER}/${GITHUB_REPO}`);
+    
+    // Test creating a test file
+    const testPath = "test-connection.txt";
+    const testContent = `Connection test at ${new Date().toISOString()}`;
+    
+    await githubApi.put(
+      `/repos/${GITHUB_OWNER}/${GITHUB_REPO}/contents/${testPath}`,
+      {
+        message: "Test connection from session server",
+        content: Buffer.from(testContent).toString("base64"),
+        branch: GITHUB_BRANCH
+      }
+    );
+
+    // Delete the test file
+    const fileInfo = await githubApi.get(`/repos/${GITHUB_OWNER}/${GITHUB_REPO}/contents/${testPath}`);
+    await githubApi.delete(`/repos/${GITHUB_OWNER}/${GITHUB_REPO}/contents/${testPath}`, {
+      data: {
+        message: "Clean up test file",
+        sha: fileInfo.data.sha,
+        branch: GITHUB_BRANCH
+      }
+    });
+
+    res.json({
+      success: true,
+      message: "GitHub connection test successful",
+      repo: repoResponse.data.full_name,
+      owner: repoResponse.data.owner.login,
+      default_branch: repoResponse.data.default_branch,
+      permissions: repoResponse.data.permissions
+    });
+  } catch (error) {
+    console.error("GitHub test error:", error.response?.data || error.message);
+    res.status(500).json({
+      success: false,
+      error: "GitHub connection failed",
+      details: error.response?.data || error.message
+    });
+  }
+});
+
+// Helper function for default settings
+function getDefaultSettings() {
+  return {
+    autoreact: false,
+    autostatusview: false,
+    autostatusreact: false,
+    autotype: false,
+    autodelete: false,
+    antilink: false,
+    badwords: false,
+    prefix: ".",
+    language: "en",
+    botmode: "public",
+    autorecording: false
+  };
+}
+
+// -------------------- GLOBAL HANDLERS -------------------- //
+process.on("uncaughtException", (err) => console.error("Uncaught Exception:", err));
+process.on("unhandledRejection", (err) => console.error("Unhandled Rejection:", err));
+
+app.listen(PORT, '0.0.0.0', () => {
+  console.log(`✅ Session server running on port ${PORT}`);
+  console.log(`📁 Storage: GitHub (${GITHUB_OWNER}/${GITHUB_REPO})`);
+  console.log(`🔑 Using token: ${GITHUB_TOKEN.substring(0, 10)}...`);
+});