Aatmanova Cloud Manager — Enterprise Rclone GUI

rclone-manager/
├── backend/
│   ├── src/
│   │   ├── services/     # Core logic (Rclone, Auth, Audit, Scheduler)
│   │   ├── routes/       # API endpoints
│   │   ├── middleware/  # Security & validation
│   │   └── types/        # TypeScript definitions
│   └── tests/           # Jest unit tests
├── frontend-next/       # Next.js 14 web client
│   ├── app/             # Pages
│   ├── components/      # UI components
│   └── hooks/           # Custom hooks
├── docker-compose.yml
└── Dockerfile.prod

// backend/src/services/rclone.service.ts
export class RcloneService {
  private async forwardRequest(hostId: string, endpoint: string, body?: any) {
    const host = await this.getHostConfig(hostId);
    
    // Validate host is accessible
    const health = await this.checkHostHealth(host);
    if (!health.online) {
      throw new Error(`Host ${host.name} is offline`);
    }
    
    // Forward request to specific host's Rclone RC
    const response = await axios.post(
      `${host.rcUrl}/ ${endpoint}`,
      body,
      {
        auth: {
          username: host.rcUser,
          password: host.rcPass,
        },
        timeout: 30000,
      }
    );
    
    return response.data;
  }
  
  async listRemotes(hostId: string) {
    return this.forwardRequest(hostId, '/config/listremotes');
  }
  
  async copyFile(hostId: string, srcRemote: string, dstRemote: string, srcPath: string, dstPath: string) {
    return this.forwardRequest(hostId, '/operations/copyfile', {
      srcFs: `${srcRemote}:${srcPath}`,
      dstFs: `${dstRemote}:${dstPath}`,
    });
  }
}

// backend/src/middleware/auth.middleware.ts
export function authenticate(req: Request, res: Response, next: NextFunction) {
  if (!req.session.userId) {
    return res.status(401).json({ error: 'Unauthorized' });
  }
  
  const user = userService.getById(req.session.userId);
  if (!user || !user.isActive) {
    return res.status(401).json({ error: 'User not found or inactive' });
  }
  
  req.user = user;
  next();
}

export function authorize(...roles: string[]) {
  return (req: Request, res: Response, next: NextFunction) => {
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({ error: 'Forbidden' });
    }
    next();
  };
}

// Usage
router.get('/hosts', authenticate, authorize('ADMIN'), listHosts);
router.get('/files', authenticate, listFiles); // Any authenticated user

// backend/src/services/stats.service.ts
export class StatsService {
  private wsClients: Set<WebSocket> = new Set();
  
  constructor() {
    // Poll Rclone stats every second
    setInterval(async () => {
      const stats = await this.gatherStats();
      this.broadcast(stats);
    }, 1000);
  }
  
  private async gatherStats() {
    const activeJobs = await rcloneService.getJobs();
    const transfers = await rcloneService.getTransferStats();
    const system = await this.getSystemResources();
    
    return {
      jobs: activeJobs,
      transfers: transfers,
      cpu: system.cpu,
      memory: system.memory,
      bandwidth: system.bandwidth,
    };
  }
  
  private broadcast(data: any) {
    this.wsClients.forEach(client => {
      if (client.readyState === WebSocket.OPEN) {
        client.send(JSON.stringify(data));
      }
    });
  }
}

// backend/src/services/scheduler.service.ts
export class SchedulerService {
  async createSchedule(scheduleData: CreateScheduleDto) {
    // Validate cron expression
    const cron = cronParser.parseExpression(scheduleData.cronExpression);
    const nextRun = cron.next().toDate();
    
    const schedule = await db.schedules.create({
      data: {
        name: scheduleData.name,
        hostId: scheduleData.hostId,
        command: scheduleData.command,
        sourceRemote: scheduleData.sourceRemote,
        destinationRemote: scheduleData.destinationRemote,
        cronExpression: scheduleData.cronExpression,
        nextRunAt: nextRun,
        isActive: true,
      },
    });
    
    // Schedule the job
    this.scheduleJob(schedule);
    
    return schedule;
  }
  
  private scheduleJob(schedule: Schedule) {
    const job = cron.schedule(schedule.cronExpression, async () => {
      await this.executeJob(schedule);
      
      // Update next run time
      const next = cronParser.parseExpression(schedule.cronExpression).next();
      await db.schedules.update({
        where: { id: schedule.id },
        data: { lastRunAt: new Date(), nextRunAt: next.toDate() },
      });
    });
    
    this.jobs.set(schedule.id, job);
  }
}

// backend/src/services/config.service.ts
export class ConfigService {
  async backupConfig(hostId: string) {
    const host = await db.hosts.findUnique({ where: { id: hostId }});
    const config = await rcloneService.getConfigDump(host);
    
    // Store backup with timestamp
    const backup = await db.configBackups.create({
      data: {
        hostId,
        configData: config,
        backupType: 'MANUAL',
      },
    });
    
    // Keep only last 10 backups
    await this.pruneOldBackups(hostId, 10);
    
    return backup;
  }
  
  async restoreConfig(backupId: string) {
    const backup = await db.configBackups.findUnique({ 
      where: { id: backupId }} 
    });
    
    // Verify backup integrity before restore
    if (!this.verifyConfigIntegrity(backup.configData)) {
      throw new Error('Backup integrity check failed');
    }
    
    // Restore
    await rcloneService.setConfigDump(backup.hostId, backup.configData);
    
    return { success: true };
  }
}

// All critical actions are logged
const actions = [
  'LOGIN', 'LOGOUT', 'FAILED_LOGIN',
  'FILE_DELETE', 'FILE_COPY', 'FILE_MOVE',
  'JOB_START', 'JOB_STOP', 'JOB_COMPLETE',
  'CONFIG_CREATE', 'CONFIG_UPDATE', 'CONFIG_DELETE',
  'HOST_CREATE', 'HOST_DELETE',
  'SCHEDULE_CREATE', 'SCHEDULE_UPDATE', 'SCHEDULE_DELETE',
  'MOUNT_CREATE', 'MOUNT_DELETE',
];

// Audit entry structure
{
  action: string,
  userId: string,
  hostId: string,
  details: string,
  ipAddress: string,
  userAgent: string,
  timestamp: Date,
}

# Configure environment
cp .env.prod.example .env

# Build and start
docker-compose -f docker-compose.prod.yml up -d --build