index.js

Go to the documentation of this file.

// ======================================================================
// Backend API Entry — Digital Ocean App Platform Version
// v1.0.3 - Add manual sync API endpoint
// ======================================================================
 
const express = require("express");
const cors = require("cors");
const cookieParser = require("cookie-parser");
const path = require("path");
require("dotenv").config();
 
const app = express();
 
// CORS
// ----------------------------------------------------
const allowedOrigins = [
  "http://localhost:5173",
  "http://localhost:5174",
  "http://192.168.0.188:5173",
  "http://192.168.122.1:5173",
  "https://demo.everydayoffice.au",
  "https://everydayoffice.au",
  "https://everydaytech.au",
  "https://www.everydaytech.au",
  "https://dashboard.everydaytech.au",
  "https://api.everydaytech.au",
  "https://rmm.everydaytech.au",
  "https://psa.everydaytech.au",
  "https://rmm-psa-dashboard-5jyun.ondigitalocean.app",
  "https://rmm-psa-backend-t9f7k.ondigitalocean.app",
];
 
app.use(cors({
  origin: (origin, callback) => {
    // Allow requests with no origin (mobile apps, curl, etc.)
    if (!origin) return callback(null, true);
    
    // Check if origin is in allowed list
    if (allowedOrigins.includes(origin)) return callback(null, true);
    
    // Allow any subdomain of everydaytech.au (safe regex test)
    try {
      if (/^https:\/\/([a-z0-9-]+\.)?everydaytech\.au$/i.test(origin)) {
        return callback(null, true);
      }
      
      // Allow any subdomain of everydayoffice.au
      if (/^https:\/\/([a-z0-9-]+\.)?everydayoffice\.au$/i.test(origin)) {
        return callback(null, true);
      }
    } catch (err) {
      console.error('CORS regex error:', err);
    }
    
    console.warn(`CORS blocked origin: ${origin}`);
    return callback(new Error("Not allowed by CORS"));
  },
  credentials: true,
}));
 
app.use(cookieParser());
app.use(express.json());
 
// =========================================
// ROOT ROUTES
// =========================================
app.get("/", (req, res) => {
  res.json({
    name: "RMM PSA Backend API",
    version: "1.0.0",
    status: "online",
    endpoints: {
      health: "/api/health",
      docs: "https://github.com/Independent-Business-Group/rmm-psa-backend"
    }
  });
});
 
app.get("/api", (req, res) => {
  res.json({
    message: "RMM PSA API",
    endpoints: [
      "/api/health",
      "/api/auth/login",
      "/api/tickets",
      "/api/customers",
      "/api/agents",
      "/api/monitoring"
    ]
  });
});
 
// =========================================
// PUBLIC BUILDER REDIRECTS (DEPRECATED - KEPT FOR BACKWARD COMPATIBILITY)
// =========================================
// Old agents may still reference these URLs
// Redirect to download status page
app.get("/builder/dl/:os", (req, res) => {
  const job = req.query.job;
  if (!job) return res.status(410).json({ error: "Builder service discontinued. Agent v1 no longer supported. Please use Agent v3 (MeshCentral)." });
  return res.status(410).json({ error: "Builder service discontinued. Agent v1 no longer supported. Please use Agent v3 (MeshCentral)." });
});
 
app.get("/builder/status", (req, res) => {
  const job = req.query.job;
  if (!job) return res.status(410).json({ error: "Builder service discontinued. Agent v1 no longer supported. Please use Agent v3 (MeshCentral)." });
  return res.status(410).json({ error: "Builder service discontinued. Agent v1 no longer supported. Please use Agent v3 (MeshCentral)." });
});
 
 
// ----------------------------------------------------
// Auth Bootstrap
// ----------------------------------------------------
try {
  const { ensureAuthExtras } = require("./services/initAuth");
  ensureAuthExtras().catch(e => console.error("Auth bootstrap failed:", e));
} catch (e) {
  console.error("initAuth load failed:", e);
}
 
 
// ----------------------------------------------------
// Middleware
// ----------------------------------------------------
const authenticateToken = require("./middleware/auth");
const { setTenantContext } = require("./middleware/tenant");
 
 
// ----------------------------------------------------
// CORE API ROUTES
/**
 *
 * @param path
 * @param mod
 */
function debugRoute(path, mod) {
  const type = typeof mod;
  const isRouter = mod && mod.stack && Array.isArray(mod.stack);
  console.log(`[DEBUG] Mounting ${path}: type=${type}, isRouter=${isRouter}`);
}
 
const routes = [
  ["/api", require("./routes/ai")],
  ["/api", require("./routes/downloadJob")],
  ["/api/download", require("./routes/download")],
  ["/api/users", require("./routes/users")],
  ["/api/tickets", require("./routes/tickets")],
  ["/api/customers", require("./routes/customers")],
  ["/api/invoices", require("./routes/invoices")],
  ["/api/invoices", require("./routes/invoice-payments")], // Stripe payment processing for invoices
  ["/api/invoices", require("./routes/invoice-pdf")], // PDF generation for invoices
  ["/api/invoices", require("./routes/refunds")], // Invoice refunds (tenant admin only)
  ["/api/public", require("./routes/public-invoice-payment")], // Public invoice payment (no auth - token-based)
  ["/api/public/pay", require("./routes/invoice-pdf")], // Public invoice PDF (no auth)
  ["/api/stripe/webhook", require("./routes/stripe-webhook")], // Stripe webhooks (no auth - signature verified)
  ["/api/stripe", require("./routes/stripe-connect")], // Stripe Connect dashboard integration (authenticated)
  ["/api/notifications", require("./routes/notifications")],
  ["/api/slack", require("./routes/slack")],
  ["/api/documents", require("./routes/documents")],
  ["/api/monitoring", require("./routes/monitoring")],
  ["/api/reports", require("./routes/reports")],
  ["/api/settings", require("./routes/settings")],
  ["/api/auth", require("./routes/auth")],
  ["/api/products", require("./routes/products")],
  ["/api/purchase-orders", require("./routes/purchaseOrders")],
  ["/api/contracts", require("./routes/contracts")],
  ["/api/domains", require("./routes/domains")],
  ["/api/domain-requests", require("./routes/domainRequests")],
  ["/api/cloudflare-dns", require("./routes/cloudflare-dns")], // Cloudflare DNS Management
  ["/api/office365", require("./routes/office365")], // Office 365 / Pax8 Integration
  ["/api/hosting", require("./routes/hosting")], // DigitalOcean Hosting Management
  ["/api/wordpress", require("./routes/wordpress")], // WordPress Site Creation
  ["/api/customers", require("./routes/customerMerge")], // Customer Merge Tool
  ["/api/dashboard", require("./routes/dashboard")],
  ["/api/tenants", require("./routes/tenants")],
  ["/api/tenants", require("./routes/tenantIcon")],
  ["/api/integrations", require("./routes/integrations")],
  // ["/api/plugins", require("./routes/plugins").router], // Disabled: requires agent directory not in backend-only deployment
  ["/api/rds", require("./routes/rds")],
  ["/api/scripts", require("./routes/scripts")],
  ["/api/email", require("./routes/emailAutomation")],
  ["/api/email", require("./routes/emailTracking")], // Email tracking pixel and analytics
  ["/api/orders", require("./routes/orders")],
  ["/api/github", require("./routes/github-webhook").router],
  // Agent routes (grouped) - order matters: specific routes before general ones
  ["/api/agent/v2", require("./routes/agentV2")],
  ["/api/agent", require("./routes/agentVersion")],
  ["/api/agent", require("./routes/agentManifest")],
  ["/api/agent", require("./routes/agent")],
  ["/api/agent/config", require("./routes/config")],
  // ["/api/agent/plugins", require("./routes/plugins").router], // Disabled: requires agent directory not in backend-only deployment
  ["/api/agent/commands", require("./routes/commands")],
  ["/api/agent/contracts", require("./routes/contracts")],
  ["/api/agent/cert", require("./routes/agentCert")],
  ["/api/agent/update", require("./routes/agentUpdate")],
  ["/api/agent/files", require("./routes/agentFiles")],
  // ["/api/releases", require("./routes/agent-download")], // DEPRECATED: Agent v2 downloads directly from GitHub (public repo)
];
for (const [path, mod] of routes) {
  debugRoute(path, mod);
  app.use(path, mod);
}
// ...existing code...
 
 
// ----------------------------------------------------
// BUILDER LAYER (Correct Placement + Crash Protection)
// ----------------------------------------------------
// DEPRECATED: Builder service no longer used (Agent v1 discontinued)
// Agent v2 is deprecated, Agent v3 uses MeshCentral's native agent
// Kept for backward compatibility only
try {
  const downloadJobRoute = require("./routes/downloadJob");
  app.use("/api", downloadJobRoute);
  console.log("⚠️  Builder downloadJob route loaded (DEPRECATED - Agent v1 discontinued)");
} catch (e) {
  console.error("❌ Failed loading /routes/downloadJob:", e);
}
 
try {
  const builderRoutes = require("./builder/builderRoutes");
  app.use("/api/builder", builderRoutes);
  console.log("⚠️  Builder routes loaded (DEPRECATED - Agent v1 discontinued)");
} catch (e) {
  console.error("❌ Failed loading builderRoutes:", e);
}
 
 
// ----------------------------------------------------
// XERO PLUGIN ROUTES
// ----------------------------------------------------
const { xeroRouter } = require('./plugins/xero');
app.use('/api/xero', xeroRouter);
 
// ----------------------------------------------------
// REMOTE ACCESS ROUTING
// ----------------------------------------------------
// Note: Guacamole and RustDesk routes removed - MeshCentral-only architecture
 
// ----------------------------------------------------
// MESHCENTRAL ROUTES
// ----------------------------------------------------
try {
  const meshcentralRoutes = require('./routes/meshcentral');
  app.use('/api/meshcentral', meshcentralRoutes);
  console.log('✅ MeshCentral routes loaded');
} catch (e) {
  console.error('❌ Failed loading meshcentral routes:', e.message);
  console.error('Stack:', e.stack);
}
 
// ----------------------------------------------------
// HEALTH CHECK ROUTES (llama.cpp, Redis, DB)
// ----------------------------------------------------
try {
  const healthRoutes = require('./routes/health');
  app.use('/api', healthRoutes);
  console.log('✅ Health check routes loaded');
} catch (e) {
  console.error('❌ Failed loading health routes:', e);
}
 
// ----------------------------------------------------
// WEBHOOK ROUTES (MeshCentral events, etc.)
// ----------------------------------------------------
try {
  const webhookRoutes = require('./routes/webhooks');
  app.use('/api/webhooks', webhookRoutes);
  console.log('✅ Webhook routes loaded');
} catch (e) {
  console.error('❌ Failed loading webhook routes:', e);
}
 
// ----------------------------------------------------
// SYNC ROUTES (Manual sync triggers)
// ----------------------------------------------------
try {
  const syncRoutes = require('./routes/sync');
  app.use('/api/sync', syncRoutes);
  console.log('✅ Sync routes loaded');
} catch (e) {
  console.error('❌ Failed loading sync routes:', e);
}
 
// ----------------------------------------------------
// AGENT V3 ROUTES (MeshCentral's native agent - ACTIVE)
// ----------------------------------------------------
// Agent v3 = MeshCentral's white-labeled agent (no custom builds)
// Provides download endpoints for Windows/Linux/macOS installers
try {
  const agentV3Routes = require('./routes/agent-v3');
  app.use('/api/agent-v3', agentV3Routes);
  console.log('✅ Agent v3 routes loaded (MeshCentral native agent)');
} catch (e) {
  console.error('❌ Failed loading agent-v3 routes:', e);
}
 
// ----------------------------------------------------
// TENANT MESHCENTRAL SYNC (Auto-create device groups)
// ----------------------------------------------------
try {
  const tenantSyncRoutes = require('./routes/tenant-meshcentral-sync');
  app.use('/api/tenant-meshcentral-sync', tenantSyncRoutes);
  console.log('✅ Tenant MeshCentral sync routes loaded');
} catch (e) {
  console.error('❌ Failed loading tenant-meshcentral-sync routes:', e);
}
 
// ----------------------------------------------------
// DEBUG ENDPOINTS (Development/troubleshooting)
// ----------------------------------------------------
try {
  const debugRoutes = require('./routes/debug');
  app.use('/api/debug', debugRoutes);
  console.log('✅ Debug routes loaded');
} catch (e) {
  console.error('❌ Failed loading debug routes:', e);
}
 
// ----------------------------------------------------
// CUSTOMER PORTAL ROUTES (Customer self-service)
// ----------------------------------------------------
try {
  const portalAuthRoutes = require('./routes/portalAuth');
  app.use('/api/portal/auth', portalAuthRoutes);
  console.log('✅ Customer portal auth routes loaded');
} catch (e) {
  console.error('❌ Failed loading portal auth routes:', e);
}
 
try {
  const portalCustomerRoutes = require('./routes/portalCustomer');
  app.use('/api/portal/customer', portalCustomerRoutes);
  console.log('✅ Customer portal data routes loaded');
} catch (e) {
  console.error('❌ Failed loading portal customer routes:', e);
}
 
// ----------------------------------------------------
// CUSTOMER PORTAL USER MANAGEMENT (Admin interface)
// ----------------------------------------------------
try {
  const customerUsersRoutes = require('./routes/customerUsers');
  app.use('/api/customer-users', customerUsersRoutes);
  console.log('✅ Customer users admin routes loaded');
} catch (e) {
  console.error('❌ Failed loading customer users routes:', e);
}
 
// ----------------------------------------------------
// STATIC FILES FOR AGENT DOWNLOADS
// ----------------------------------------------------
const publicPath = path.join(__dirname, 'public');
app.use('/agent', express.static(publicPath, {
  setHeaders: (res, filepath) => {
    // Set proper content type for executables and scripts
    if (filepath.endsWith('.exe')) {
      res.setHeader('Content-Type', 'application/octet-stream');
      res.setHeader('Content-Disposition', `attachment; filename="${path.basename(filepath)}"`);
    } else if (filepath.endsWith('.sh')) {
      res.setHeader('Content-Type', 'application/x-sh');
    } else if (filepath.endsWith('.bat')) {
      res.setHeader('Content-Type', 'application/x-msdos-program');
    } else if (filepath.endsWith('.ps1')) {
      res.setHeader('Content-Type', 'application/octet-stream');
    }
    // Prevent caching for downloads
    if (filepath.includes('/downloads/')) {
      res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
    }
  }
}));
console.log('✅ Static files mounted at /agent/ from', publicPath);
 
 
 
// ----------------------------------------------------
// TEST PAGES
// ----------------------------------------------------
// Guacamole test pages removed - MeshCentral-only architecture
 
// ----------------------------------------------------
// HEALTH CHECK
// ----------------------------------------------------
app.get("/api/health", (req, res) => res.status(200).send("OK"));
 
 
// ----------------------------------------------------
// WEBSOCKETS
// ----------------------------------------------------
const http = require("http");
const server = http.createServer(app);
const wsManager = require("./services/websocketManager");
 
wsManager.init(server);
 
setInterval(() => {
  const stats = wsManager.getStats();
  console.log(
    `[WS Monitor] Agents: ${stats.agents}, Dashboards: ${stats.dashboards}, Subscriptions: ${stats.subscriptions} @ ${new Date().toISOString()}`
  );
}, 30000);
 
 
// ----------------------------------------------------
// START SERVER
// ----------------------------------------------------
const PORT = process.env.PORT || 3000;
 
// Start pluginBuilder Redis worker on backend startup - DISABLED (requires agent directory)
// try {
//   const { spawn } = require('child_process');
//   const pluginBuilderPath = path.resolve(__dirname, 'services', 'pluginBuilder.js');
//   const pluginBuilder = spawn('node', [pluginBuilderPath], {
//     stdio: ['ignore', 'inherit', 'inherit'],
//     detached: true
//   });
//   console.log(`✅ pluginBuilder Redis worker started (PID: ${pluginBuilder.pid})`);
// } catch (err) {
//   console.error('❌ Failed to start pluginBuilder worker:', err.message);
// }
 
// RustDesk sync service removed - MeshCentral-only architecture
 
// Start agentDeleteWorker on backend startup
try {
  const { spawn } = require('child_process');
  const agentDeleteWorkerPath = path.resolve(__dirname, 'services', 'agentDeleteWorker.js');
  const agentDeleteWorker = spawn('node', [agentDeleteWorkerPath], {
    stdio: ['ignore', 'inherit', 'inherit'],
    detached: true
  });
  console.log(`✅ agentDeleteWorker started (PID: ${agentDeleteWorker.pid})`);
} catch (err) {
  console.error('❌ Failed to start agentDeleteWorker:', err.message);
}
 
// Start all other workers on backend startup
const workerFiles = [
  'emailPollWorker.js',
  'emailToTicketWorker.js',
  'bullmqWorker.js',
  'aiWorker.js',
  'contractBillingWorker.js',
  'digitalOceanSyncWorker.js',
  'domainSyncWorker.js',
  'dnsRecordsSyncWorker.js',
  'pax8SyncWorker.js',
  'workers/agentMonitor.js',
  'workers/meshcentralSync.js'
  // '../neto-xero/workers/netoSyncWorker.js' // Disabled: not in backend-only deployment
];
 
// Start MeshCentral Device Auto-Sync (self-initializing)
// This worker polls MeshCentral and auto-creates agents in our DB
try {
  require('./workers/meshcentral-device-sync');
  console.log('✅ MeshCentral device auto-sync worker loaded');
} catch (err) {
  console.error('❌ Failed to load MeshCentral device sync worker:', err.message);
}
for (const file of workerFiles) {
  try {
    const { spawn } = require('child_process');
    const workerPath = path.resolve(__dirname, file);
    const worker = spawn('node', [workerPath], {
      stdio: ['ignore', 'inherit', 'inherit'],
      detached: true
    });
    console.log(`✅ ${file} started (PID: ${worker.pid})`);
  } catch (err) {
    console.error(`❌ Failed to start ${file}:`, err.message);
  }
}
 
// ----------------------------------------------------
// TENANT-MESHCENTRAL STARTUP SYNC
// Auto-creates device groups for all tenants
// ----------------------------------------------------
try {
  const { initStartupSync, runStartupSync } = require('./startup/tenant-meshcentral-sync');
  
  // Run on startup
  initStartupSync();
  console.log('✅ Tenant-MeshCentral startup sync initialized');
  
  // Periodic sync every hour to ensure consistency
  const SYNC_INTERVAL = parseInt(process.env.TENANT_SYNC_INTERVAL || '3600000'); // 1 hour default
  if (SYNC_INTERVAL > 0) {
    setInterval(() => {
      console.log('\n⏰ Running scheduled tenant-mesh sync...');
      runStartupSync().catch(err => {
        console.error('❌ Scheduled sync error:', err.message);
      });
    }, SYNC_INTERVAL);
    console.log(`✅ Periodic sync scheduled every ${SYNC_INTERVAL / 60000} minutes`);
  }
} catch (err) {
  console.error('❌ Failed to initialize tenant-meshcentral sync:', err.message);
}
 
server.listen(PORT, () => {
  console.log(`✅ Backend API online (HTTP + WS) on port ${PORT}`);
});