A modern, self-hosted backup solution for secure, encrypted backups across local and cloud storage.
feat: adds the ability to connect various drives directly without external rclone
towfiqi253c659af549
diff --git a/backend/__tests__/controllers/StorageController.test.ts b/backend/__tests__/controllers/StorageController.test.tsindex 658865c..8bfb5fb 100644--- a/backend/__tests__/controllers/StorageController.test.ts+++ b/backend/__tests__/controllers/StorageController.test.ts@@ -331,11 +331,11 @@ describe('StorageController', () => {});});- describe('authorizeStorage', () => {+ describe('startAuthorize', () => {it('should return 400 if storage type is missing', async () => {- mockRequest.query = {};+ mockRequest.body = {};- await storageController.authorizeStorage(mockRequest as Request, mockResponse as Response);+ await storageController.startAuthorize(mockRequest as Request, mockResponse as Response);expect(mockStatus).toHaveBeenCalledWith(400);expect(mockJson).toHaveBeenCalledWith({@@ -344,31 +344,134 @@ describe('StorageController', () => {});});- it('should successfully authorize storage', async () => {- const authResult = { authUrl: 'https://auth.example.com', token: 'auth-token' };- mockRequest.query = { type: 'gdrive' };- mockStorageService.authorizeStorage.mockResolvedValue(authResult as any);+ it('should return 400 if storage type is not a string', async () => {+ mockRequest.body = { type: 123 };++ await storageController.startAuthorize(mockRequest as Request, mockResponse as Response);++ expect(mockStatus).toHaveBeenCalledWith(400);+ expect(mockJson).toHaveBeenCalledWith({+ success: false,+ error: 'Storage type is required',+ });+ });- await storageController.authorizeStorage(mockRequest as Request, mockResponse as Response);+ it('should successfully start authorization', async () => {+ mockRequest.body = { type: 'drive' };+ mockStorageService.startAuthorize.mockReturnValue('session-abc');- expect(mockStorageService.authorizeStorage).toHaveBeenCalledWith('gdrive');+ await storageController.startAuthorize(mockRequest as Request, mockResponse as Response);++ expect(mockStorageService.startAuthorize).toHaveBeenCalledWith('drive');expect(mockStatus).toHaveBeenCalledWith(200);expect(mockJson).toHaveBeenCalledWith({success: true,- result: authResult,+ result: { sessionId: 'session-abc' },});});- it('should return 500 if service throws an error', async () => {- mockRequest.query = { type: 'gdrive' };- mockStorageService.authorizeStorage.mockRejectedValue(new Error('Authorization failed'));+ it('should forward service errors with statusCode', async () => {+ mockRequest.body = { type: 'drive' };+ const error = { statusCode: 409, message: 'Already in progress' };+ mockStorageService.startAuthorize.mockImplementation(() => {+ throw error;+ });- await storageController.authorizeStorage(mockRequest as Request, mockResponse as Response);+ await storageController.startAuthorize(mockRequest as Request, mockResponse as Response);- expect(mockStatus).toHaveBeenCalledWith(500);+ expect(mockStatus).toHaveBeenCalledWith(409);+ expect(mockJson).toHaveBeenCalledWith({+ success: false,+ error: 'Already in progress',+ });+ });+ });++ describe('getAuthorizeStatus', () => {+ it('should return 400 if sessionId is missing', async () => {+ mockRequest.query = {};++ await storageController.getAuthorizeStatus(mockRequest as Request, mockResponse as Response);++ expect(mockStatus).toHaveBeenCalledWith(400);+ expect(mockJson).toHaveBeenCalledWith({+ success: false,+ error: 'Session ID is required',+ });+ });++ it('should successfully return authorize status', async () => {+ mockRequest.query = { sessionId: 'session-abc' };+ const statusResult = {+ status: 'success',+ token: '{"access_token":"xyz"}',+ };+ mockStorageService.getAuthorizeStatus.mockReturnValue(statusResult as any);++ await storageController.getAuthorizeStatus(mockRequest as Request, mockResponse as Response);++ expect(mockStorageService.getAuthorizeStatus).toHaveBeenCalledWith('session-abc');+ expect(mockStatus).toHaveBeenCalledWith(200);+ expect(mockJson).toHaveBeenCalledWith({+ success: true,+ result: statusResult,+ });+ });++ it('should forward 404 for unknown session', async () => {+ mockRequest.query = { sessionId: 'nonexistent' };+ const error = { statusCode: 404, message: 'Authorization session not found' };+ mockStorageService.getAuthorizeStatus.mockImplementation(() => {+ throw error;+ });++ await storageController.getAuthorizeStatus(mockRequest as Request, mockResponse as Response);++ expect(mockStatus).toHaveBeenCalledWith(404);+ expect(mockJson).toHaveBeenCalledWith({+ success: false,+ error: 'Authorization session not found',+ });+ });+ });++ describe('cancelAuthorize', () => {+ it('should return 400 if sessionId is missing', async () => {+ mockRequest.body = {};++ await storageController.cancelAuthorize(mockRequest as Request, mockResponse as Response);++ expect(mockStatus).toHaveBeenCalledWith(400);+ expect(mockJson).toHaveBeenCalledWith({+ success: false,+ error: 'Session ID is required',+ });+ });++ it('should successfully cancel authorization', async () => {+ mockRequest.body = { sessionId: 'session-abc' };+ mockStorageService.cancelAuthorize.mockReturnValue(undefined);++ await storageController.cancelAuthorize(mockRequest as Request, mockResponse as Response);++ expect(mockStorageService.cancelAuthorize).toHaveBeenCalledWith('session-abc');+ expect(mockStatus).toHaveBeenCalledWith(200);+ expect(mockJson).toHaveBeenCalledWith({ success: true });+ });++ it('should forward 404 for unknown session', async () => {+ mockRequest.body = { sessionId: 'nonexistent' };+ const error = { statusCode: 404, message: 'Authorization session not found' };+ mockStorageService.cancelAuthorize.mockImplementation(() => {+ throw error;+ });++ await storageController.cancelAuthorize(mockRequest as Request, mockResponse as Response);++ expect(mockStatus).toHaveBeenCalledWith(404);expect(mockJson).toHaveBeenCalledWith({success: false,- error: 'Failed to authorize storage',+ error: 'Authorization session not found',});});});diff --git a/backend/__tests__/services/StorageService.test.ts b/backend/__tests__/services/StorageService.test.tsindex d37fa8f..57bdf49 100644--- a/backend/__tests__/services/StorageService.test.ts+++ b/backend/__tests__/services/StorageService.test.ts@@ -8,9 +8,9 @@ import { LocalStrategy, RemoteStrategy } from '../../src/strategies/system';import { AppError } from '../../src/utils/AppError';import { NewStorage, Storage } from '../../src/db/schema/storages';import { generateUID } from '../../src/utils/helpers';-import { runCommand } from '../../src/utils/runCommand';+import { spawnRcloneAuthorize } from '../../src/utils/rclone/helpers';-jest.mock('../../src/utils/runCommand');+jest.mock('../../src/utils/rclone/helpers');// Mock dependenciesjest.mock('../../src/stores/StorageStore');@@ -31,7 +31,7 @@ jest.mock('../../src/services/ConfigService', () => ({},}));-const mockRunCommand = runCommand as jest.Mock;+const mockSpawnRcloneAuthorize = spawnRcloneAuthorize as jest.Mock;describe('StorageService', () => {let storageService: StorageService;@@ -322,39 +322,130 @@ describe('StorageService', () => {});// ----------------------------------------- // authorizeStorage+ // startAuthorize// ----------------------------------------- describe('authorizeStorage', () => {- it('should call rclone authorize and return the token', async () => {- const mockToken = { access_token: 'xyz', expiry: '2025-10-26T10:00:00Z' };- const rcloneOutput = `--->\n\n${JSON.stringify(mockToken)}\n\n<---`;- mockRunCommand.mockResolvedValue(rcloneOutput);-- const result = await storageService.authorizeStorage('drive');-- expect(mockRunCommand).toHaveBeenCalledWith(- ['rclone', 'authorize', 'drive', '--auth-no-open-browser'],- undefined,- expect.any(Function)+ describe('startAuthorize', () => {+ it('should return a session ID for a valid OAuth storage type', () => {+ const sessionId = storageService.startAuthorize('drive');++ expect(sessionId).toBe('mock-uid-123');+ expect(mockSpawnRcloneAuthorize).toHaveBeenCalledWith(+ expect.objectContaining({+ id: 'mock-uid-123',+ storageType: 'drive',+ status: 'pending',+ }),+ expect.any(Number));- expect(result).toEqual(mockToken);});- it('should throw an AppError if rclone command fails', async () => {- mockRunCommand.mockRejectedValue(new Error('Command failed'));-- await expect(storageService.authorizeStorage('drive')).rejects.toThrow(AppError);- await expect(storageService.authorizeStorage('drive')).rejects.toThrow(- 'Failed to authorize drive: Command failed'+ it('should throw 400 for unknown storage type', () => {+ expect(() => storageService.startAuthorize('nonexistent')).toThrow(AppError);+ expect(() => storageService.startAuthorize('nonexistent')).toThrow(+ 'Unknown storage type: nonexistent');});- it('should throw an AppError if token cannot be extracted', async () => {- mockRunCommand.mockResolvedValue('Some unexpected output');+ it('should throw 400 for storage type that does not support OAuth', () => {+ // 'local' does not have oauth in authTypes+ expect(() => storageService.startAuthorize('local')).toThrow(AppError);+ expect(() => storageService.startAuthorize('local')).toThrow('does not support OAuth');+ });- await expect(storageService.authorizeStorage('drive')).rejects.toThrow(- 'Could not extract drive token from output'- );+ it('should throw 409 if a session is already pending', () => {+ storageService.startAuthorize('drive');+ (generateUID as jest.Mock).mockReturnValue('mock-uid-456');++ expect(() => storageService.startAuthorize('drive')).toThrow(AppError);+ expect(() => storageService.startAuthorize('drive')).toThrow('already in progress');+ });+ });++ // ----------------------------------------+ // getAuthorizeStatus+ // ----------------------------------------+ describe('getAuthorizeStatus', () => {+ it('should return pending status for an active session', () => {+ const sessionId = storageService.startAuthorize('drive');+ const status = storageService.getAuthorizeStatus(sessionId);++ expect(status).toEqual({ status: 'pending' });+ });++ it('should throw 404 for unknown session ID', () => {+ expect(() => storageService.getAuthorizeStatus('nonexistent')).toThrow(AppError);+ expect(() => storageService.getAuthorizeStatus('nonexistent')).toThrow('session not found');+ });++ it('should clean up completed sessions after reading', () => {+ // Manipulate session via spawnRcloneAuthorize mock+ mockSpawnRcloneAuthorize.mockImplementation(session => {+ session.status = 'success';+ session.token = '{"access_token":"xyz"}';+ });++ const sessionId = storageService.startAuthorize('drive');+ const status = storageService.getAuthorizeStatus(sessionId);++ expect(status.status).toBe('success');+ expect(status.token).toBe('{"access_token":"xyz"}');++ // Second read should throw 404+ expect(() => storageService.getAuthorizeStatus(sessionId)).toThrow('session not found');+ });++ it('should include authUrl when available', () => {+ mockSpawnRcloneAuthorize.mockImplementation(session => {+ session.authUrl = 'http://127.0.0.1:53682/auth';+ });++ const sessionId = storageService.startAuthorize('drive');+ const status = storageService.getAuthorizeStatus(sessionId);++ expect(status.authUrl).toBe('http://127.0.0.1:53682/auth');+ });++ it('should include error when available', () => {+ mockSpawnRcloneAuthorize.mockImplementation(session => {+ session.status = 'error';+ session.error = 'Authorization timed out';+ });++ const sessionId = storageService.startAuthorize('drive');+ const status = storageService.getAuthorizeStatus(sessionId);++ expect(status.status).toBe('error');+ expect(status.error).toBe('Authorization timed out');+ });+ });++ // ----------------------------------------+ // cancelAuthorize+ // ----------------------------------------+ describe('cancelAuthorize', () => {+ it('should kill the process and remove the session', () => {+ const mockKill = jest.fn();+ mockSpawnRcloneAuthorize.mockImplementation(session => {+ session.process = { killed: false, kill: mockKill } as any;+ });++ const sessionId = storageService.startAuthorize('drive');+ storageService.cancelAuthorize(sessionId);++ expect(mockKill).toHaveBeenCalled();+ // Session should be gone+ expect(() => storageService.getAuthorizeStatus(sessionId)).toThrow('session not found');+ });++ it('should throw 404 for unknown session ID', () => {+ expect(() => storageService.cancelAuthorize('nonexistent')).toThrow(AppError);+ expect(() => storageService.cancelAuthorize('nonexistent')).toThrow('session not found');+ });++ it('should handle session without a process reference', () => {+ // Don't set process in mock+ const sessionId = storageService.startAuthorize('drive');+ expect(() => storageService.cancelAuthorize(sessionId)).not.toThrow();});});});diff --git a/backend/__tests__/utils/rclone/helpers.test.ts b/backend/__tests__/utils/rclone/helpers.test.tsindex 4a24daa..200ccc6 100644--- a/backend/__tests__/utils/rclone/helpers.test.ts+++ b/backend/__tests__/utils/rclone/helpers.test.ts@@ -1,10 +1,22 @@import path from 'path';import os from 'os';+import { ChildProcess } from 'child_process';import { appPaths } from '../../../src/utils/AppPaths';-import { encryptRcloneConfig, getRcloneConfigPath } from '../../../src/utils/rclone/helpers';+import {+ encryptRcloneConfig,+ getRcloneConfigPath,+ spawnRcloneAuthorize,+ RcloneAuthSession,+} from '../../../src/utils/rclone/helpers';import { runRcloneCommand } from '../../../src/utils/rclone/rclone';+import { runCommand } from '../../../src/utils/runCommand';+import { getBinaryPath } from '../../../src/utils/binaryPathResolver';+import { getInstallType } from '../../../src/utils/installHelpers';jest.mock('os');+jest.mock('../../../src/utils/runCommand');+jest.mock('../../../src/utils/binaryPathResolver');+jest.mock('../../../src/utils/installHelpers');describe('rclone helpers', () => {describe('getRcloneConfigPath', () => {@@ -256,4 +268,231 @@ describe('rclone helpers', () => {expect(result.result).toBe('');});});++ describe('spawnRcloneAuthorize', () => {+ const mockRunCommand = runCommand as jest.Mock;+ const mockGetBinaryPath = getBinaryPath as jest.Mock;+ const mockGetInstallType = getInstallType as jest.Mock;++ let session: RcloneAuthSession;++ beforeEach(() => {+ jest.clearAllMocks();+ jest.useFakeTimers();++ mockGetBinaryPath.mockReturnValue('/usr/bin/rclone');+ mockGetInstallType.mockReturnValue('binary');+ jest.spyOn(console, 'log').mockImplementation();++ session = {+ id: 'test-session-1',+ storageType: 'drive',+ status: 'pending',+ startedAt: Date.now(),+ };++ // Default: runCommand resolves immediately+ mockRunCommand.mockResolvedValue('');+ });++ afterEach(() => {+ jest.useRealTimers();+ jest.restoreAllMocks();+ });++ it('should spawn rclone with correct args for binary install', () => {+ mockGetInstallType.mockReturnValue('binary');+ spawnRcloneAuthorize(session, 300_000);++ expect(mockRunCommand).toHaveBeenCalledWith(+ ['/usr/bin/rclone', 'authorize', 'drive'],+ {},+ expect.any(Function),+ expect.any(Function),+ expect.any(Function),+ expect.any(Function)+ );+ });++ it('should add --auth-no-open-browser for docker installs', () => {+ mockGetInstallType.mockReturnValue('docker');+ spawnRcloneAuthorize(session, 300_000);++ expect(mockRunCommand).toHaveBeenCalledWith(+ ['/usr/bin/rclone', 'authorize', 'drive', '--auth-no-open-browser'],+ {},+ expect.any(Function),+ expect.any(Function),+ expect.any(Function),+ expect.any(Function)+ );+ });++ it('should add --auth-no-open-browser for server installs', () => {+ mockGetInstallType.mockReturnValue('server');+ spawnRcloneAuthorize(session, 300_000);++ expect(mockRunCommand).toHaveBeenCalledWith(+ ['/usr/bin/rclone', 'authorize', 'drive', '--auth-no-open-browser'],+ {},+ expect.any(Function),+ expect.any(Function),+ expect.any(Function),+ expect.any(Function)+ );+ });++ it('should not add --auth-no-open-browser for dev installs', () => {+ mockGetInstallType.mockReturnValue('dev');+ spawnRcloneAuthorize(session, 300_000);++ const callArgs = mockRunCommand.mock.calls[0][0];+ expect(callArgs).not.toContain('--auth-no-open-browser');+ });++ it('should extract token from stdout via onProgress callback', () => {+ mockRunCommand.mockImplementation((args, env, onProgress, onError, onComplete, onSpawn) => {+ const token = JSON.stringify({ access_token: 'xyz', expiry: '2025-10-26T10:00:00Z' });+ const chunk = `Paste the following into your remote machine --->\n${token}\n<---`;+ onProgress?.(Buffer.from(chunk));+ return Promise.resolve('');+ });++ spawnRcloneAuthorize(session, 300_000);++ expect(session.status).toBe('success');+ expect(session.token).toBe('{"access_token":"xyz","expiry":"2025-10-26T10:00:00Z"}');+ });++ it('should extract auth URL from stderr via onError callback', () => {+ mockRunCommand.mockImplementation((args, env, onProgress, onError, onComplete, onSpawn) => {+ onError?.(+ Buffer.from(+ "If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth\n"+ )+ );+ return Promise.resolve('');+ });++ spawnRcloneAuthorize(session, 300_000);++ expect(session.authUrl).toBe('http://127.0.0.1:53682/auth');+ });++ it('should capture process reference via onSpawn callback', () => {+ const mockProcess = { killed: false, kill: jest.fn() } as unknown as ChildProcess;++ mockRunCommand.mockImplementation((args, env, onProgress, onError, onComplete, onSpawn) => {+ onSpawn?.(mockProcess);+ return Promise.resolve('');+ });++ spawnRcloneAuthorize(session, 300_000);++ expect(session.process).toBe(mockProcess);+ });++ it('should set error status on timeout', () => {+ const mockProcess = { killed: false, kill: jest.fn() } as unknown as ChildProcess;++ mockRunCommand.mockImplementation((args, env, onProgress, onError, onComplete, onSpawn) => {+ onSpawn?.(mockProcess);+ // Never resolves - simulates long-running process+ return new Promise(() => {});+ });++ spawnRcloneAuthorize(session, 5000);++ expect(session.status).toBe('pending');+ jest.advanceTimersByTime(5000);+ expect(session.status).toBe('error');+ expect(session.error).toContain('timed out');+ expect(mockProcess.kill).toHaveBeenCalled();+ });++ it('should extract token in onComplete when stdout had the token', () => {+ mockRunCommand.mockImplementation((args, env, onProgress, onError, onComplete, onSpawn) => {+ const token = JSON.stringify({ access_token: 'abc' });+ onProgress?.(Buffer.from(`--->\n${token}\n<---`));+ // onProgress already extracted token, but test onComplete path+ // Reset to pending to test onComplete extraction+ return Promise.resolve('');+ });++ spawnRcloneAuthorize(session, 300_000);+ expect(session.status).toBe('success');+ });++ it('should extract token in catch handler when runCommand rejects', async () => {+ mockRunCommand.mockImplementation((args, env, onProgress, onError, onComplete, onSpawn) => {+ const token = JSON.stringify({ access_token: 'from-catch' });+ onProgress?.(Buffer.from(`--->\n${token}\n<---`));+ // Token extracted via onProgress, then reject+ return Promise.reject(new Error('exit code 1'));+ });++ spawnRcloneAuthorize(session, 300_000);++ // Let microtasks (catch handler) run+ await Promise.resolve();++ expect(session.status).toBe('success');+ expect(session.token).toBe('{"access_token":"from-catch"}');+ });++ it('should set error status when runCommand rejects without token', async () => {+ mockRunCommand.mockImplementation((args, env, onProgress, onError, onComplete, onSpawn) => {+ return Promise.reject(new Error('spawn failed'));+ });++ spawnRcloneAuthorize(session, 300_000);++ await Promise.resolve();++ expect(session.status).toBe('error');+ expect(session.error).toBe('spawn failed');+ });++ it('should set error when onComplete fires with no token', () => {+ mockRunCommand.mockImplementation((args, env, onProgress, onError, onComplete, onSpawn) => {+ onComplete?.(1);+ return Promise.resolve('');+ });++ spawnRcloneAuthorize(session, 300_000);++ expect(session.status).toBe('error');+ expect(session.error).toContain('exited with code 1');+ });++ it('should not overwrite success status in catch handler', async () => {+ mockRunCommand.mockImplementation((args, env, onProgress, onError, onComplete, onSpawn) => {+ const token = JSON.stringify({ access_token: 'valid' });+ onProgress?.(Buffer.from(`--->\n${token}\n<---`));+ // Token already extracted to success, then reject+ return Promise.reject(new Error('exit code 1'));+ });++ spawnRcloneAuthorize(session, 300_000);+ expect(session.status).toBe('success');++ await Promise.resolve();++ // Should still be success, not overwritten+ expect(session.status).toBe('success');+ expect(session.token).toBe('{"access_token":"valid"}');+ });++ it('should not extract invalid JSON as token', () => {+ mockRunCommand.mockImplementation((args, env, onProgress, onError, onComplete, onSpawn) => {+ onProgress?.(Buffer.from('--->\nnot valid json\n<---'));+ return Promise.resolve('');+ });++ spawnRcloneAuthorize(session, 300_000);++ expect(session.token).toBeUndefined();+ expect(session.status).toBe('pending');+ });+ });});diff --git a/backend/src/controllers/StorageController.ts b/backend/src/controllers/StorageController.tsindex b71d9f9..ea99ca9 100644--- a/backend/src/controllers/StorageController.ts+++ b/backend/src/controllers/StorageController.ts@@ -90,12 +90,10 @@ export class StorageController {StorageLogger.error(`Error deleting storage #${req.params.id}. Reason : ${error?.message.toString() || 'Unknown Error'}`);- res- .status(500)- .json({- success: false,- error: `Failed to delete storage. Reason : ${error?.message.toString() || 'Unknown Error'}`,- });+ res.status(500).json({+ success: false,+ error: `Failed to delete storage. Reason : ${error?.message.toString() || 'Unknown Error'}`,+ });}}@@ -113,16 +111,57 @@ export class StorageController {}}- async authorizeStorage(req: Request, res: Response): Promise<void> {+ async startAuthorize(req: Request, res: Response): Promise<void> {try {- if (!req.query.type) {+ const storageType = req.body?.type;+ if (!storageType || typeof storageType !== 'string') {res.status(400).json({ success: false, error: 'Storage type is required' });return;}- const rcloneAuthResp = await this.storageService.authorizeStorage(req.query.type as string);- res.status(200).json({ success: true, result: rcloneAuthResp });+ const sessionId = this.storageService.startAuthorize(storageType);+ res.status(200).json({ success: true, result: { sessionId } });+ } catch (error: any) {+ const status = error?.statusCode || 500;+ res.status(status).json({+ success: false,+ error: error?.message || 'Failed to start authorization',+ });+ }+ }++ async getAuthorizeStatus(req: Request, res: Response): Promise<void> {+ try {+ const sessionId = req.query.sessionId as string;+ if (!sessionId) {+ res.status(400).json({ success: false, error: 'Session ID is required' });+ return;+ }+ const status = this.storageService.getAuthorizeStatus(sessionId);+ res.status(200).json({ success: true, result: status });} catch (error: any) {- res.status(500).json({ success: false, error: 'Failed to authorize storage' });+ const httpStatus = error?.statusCode || 500;+ res.status(httpStatus).json({+ success: false,+ error: error?.message || 'Failed to get authorization status',+ });+ }+ }++ async cancelAuthorize(req: Request, res: Response): Promise<void> {+ try {+ const sessionId = req.body?.sessionId;+ if (!sessionId) {+ res.status(400).json({ success: false, error: 'Session ID is required' });+ return;+ }+ this.storageService.cancelAuthorize(sessionId);+ res.status(200).json({ success: true });+ } catch (error: any) {+ const status = error?.statusCode || 500;+ res.status(status).json({+ success: false,+ error: error?.message || 'Failed to cancel authorization',+ });}}}diff --git a/backend/src/routes/storages.ts b/backend/src/routes/storages.tsindex 1d0e413..6c3af25 100644--- a/backend/src/routes/storages.ts+++ b/backend/src/routes/storages.ts@@ -13,7 +13,9 @@ export function createStorageRouter(router.put('/:id', authM, controller.updateStorage.bind(controller));router.delete('/:id', authM, controller.deleteStorage.bind(controller));router.post('/verify/:id', authM, controller.verifyStorage.bind(controller));- // router.post('/auth', controller.authorizeStorage.bind(controller));+ router.post('/authorize', authM, controller.startAuthorize.bind(controller));+ router.get('/authorize/status', authM, controller.getAuthorizeStatus.bind(controller));+ router.post('/authorize/cancel', authM, controller.cancelAuthorize.bind(controller));return router;}diff --git a/backend/src/services/StorageService.ts b/backend/src/services/StorageService.tsindex ab9eab6..fce9e9a 100644--- a/backend/src/services/StorageService.ts+++ b/backend/src/services/StorageService.ts@@ -10,10 +10,14 @@ import {SystemStrategy,} from '../strategies/system';import { generateUID } from '../utils/helpers';-import { runCommand } from '../utils/runCommand';import { BaseSystemManager } from '../managers/BaseSystemManager';import { configService } from './ConfigService';import { AppError, NotFoundError } from '../utils/AppError';+import {+ spawnRcloneAuthorize,+ RcloneAuthSession,+ RcloneAuthSessionStatus,+} from '../utils/rclone/helpers';/*** A class for managing storage operations.@@ -314,39 +318,75 @@ export class StorageService {}}- async authorizeStorage(type: string): Promise<string> {- try {- const rcloneAuthResp = await this.getRcloneStorageToken(type);- return rcloneAuthResp;- } catch (error: any) {- if (error instanceof AppError) {- throw error;+ // ── OAuth Authorization Session Management ──────────────────────────++ private authSessions = new Map<string, RcloneAuthSession>();+ private readonly AUTH_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes++ startAuthorize(storageType: string): string {+ // Validate storage type+ if (!providers[storageType]) {+ throw new AppError(400, `Unknown storage type: ${storageType}`);+ }+ const provider = providers[storageType];+ if (!provider.authTypes?.includes('oauth')) {+ throw new AppError(400, `Storage type "${storageType}" does not support OAuth`);+ }++ // Allow only one concurrent auth session+ for (const [id, session] of this.authSessions) {+ if (session.status === 'pending') {+ throw new AppError(+ 409,+ 'An authorization session is already in progress. Cancel it first or wait for it to complete.'+ );}- throw new AppError(500, error?.message || 'Failed to authorize storage');}++ const sessionId = generateUID();+ const session: RcloneAuthSession = {+ id: sessionId,+ storageType,+ status: 'pending',+ startedAt: Date.now(),+ };+ this.authSessions.set(sessionId, session);++ // Spawn rclone authorize in background+ spawnRcloneAuthorize(session, this.AUTH_TIMEOUT_MS);++ return sessionId;}- private async getRcloneStorageToken(storageType: string): Promise<string> {- try {- const output = await runCommand(- ['rclone', 'authorize', storageType, '--auth-no-open-browser'],- undefined,- log => console.log('[auth] ', log)- );+ getAuthorizeStatus(sessionId: string): RcloneAuthSessionStatus {+ const session = this.authSessions.get(sessionId);+ if (!session) {+ throw new AppError(404, 'Authorization session not found');+ }- // Extract the JSON string between the markers- const tokenMatch = output.match(/--->\n\n(.*?)\n\n<---/s);- if (tokenMatch && tokenMatch[1]) {- const tokenJson = JSON.parse(tokenMatch[1]);- return tokenJson;- }+ const result: RcloneAuthSessionStatus = {+ status: session.status,+ };+ if (session.authUrl) result.authUrl = session.authUrl;+ if (session.token) result.token = session.token;+ if (session.error) result.error = session.error;- throw new AppError(500, `Could not extract ${storageType} token from output`);- } catch (error: any) {- if (error instanceof AppError) {- throw error;- }- throw new AppError(500, `Failed to authorize ${storageType}: ${error.message}`);+ // Clean up completed/errored sessions after they've been read+ if (session.status === 'success' || session.status === 'error') {+ this.authSessions.delete(sessionId);+ }++ return result;+ }++ cancelAuthorize(sessionId: string): void {+ const session = this.authSessions.get(sessionId);+ if (!session) {+ throw new AppError(404, 'Authorization session not found');+ }+ if (session.process && !session.process.killed) {+ session.process.kill();}+ this.authSessions.delete(sessionId);}}diff --git a/backend/src/utils/providers/gdrive.ts b/backend/src/utils/providers/gdrive.tsindex da588b9..da49269 100644--- a/backend/src/utils/providers/gdrive.ts+++ b/backend/src/utils/providers/gdrive.ts@@ -61,7 +61,7 @@ const googleDriveSettings = [value: 'token',fieldType: 'password',authFieldType: 'oauth',- required: false,+ required: true,default: '',description: 'OAuth Access Token as a JSON blob.',command: '--drive-token',diff --git a/backend/src/utils/rclone/helpers.ts b/backend/src/utils/rclone/helpers.tsindex bf66fb3..73b65c1 100644--- a/backend/src/utils/rclone/helpers.ts+++ b/backend/src/utils/rclone/helpers.ts@@ -1,19 +1,29 @@+import { ChildProcess } from 'child_process';import path from 'path';import os from 'os';import { appPaths } from '../AppPaths';import { runRcloneCommand } from './rclone';+import { runCommand } from '../runCommand';+import { getBinaryPath } from '../binaryPathResolver';+import { getInstallType } from '../installHelpers';-// export const getRcloneConfigPath = (secure = false) => {-// let rcloneConfigPath = '';-// let fileName = secure ? 'rclone.conf.enc' : 'rclone.conf';-// if (process.platform === 'win32') {-// rcloneConfigPath = path.join(process.env.APPDATA || '', 'rclone', fileName);-// } else {-// rcloneConfigPath = path.join(os.homedir(), `.config/rclone/${fileName}`);-// }+export interface RcloneAuthSession {+ id: string;+ storageType: string;+ status: 'pending' | 'success' | 'error';+ token?: string;+ error?: string;+ authUrl?: string;+ process?: ChildProcess;+ startedAt: number;+}-// return rcloneConfigPath;-// };+export interface RcloneAuthSessionStatus {+ status: 'pending' | 'success' | 'error';+ token?: string;+ error?: string;+ authUrl?: string;+}export const getRcloneConfigPath = (secure = false) => {const fileName = secure ? 'rclone.conf.enc' : 'rclone.conf';@@ -63,3 +73,107 @@ export async function encryptRcloneConfig(}}}++/**+ * Spawns `rclone authorize <storageType>` in the background.+ * Updates the provided AuthSession object in-place as stdout/stderr arrive.+ * On desktop installs the browser opens automatically;+ * on docker/server installs `--auth-no-open-browser` is added.+ */+export function spawnRcloneAuthorize(session: RcloneAuthSession, timeoutMs: number): void {+ const rcloneBinary = getBinaryPath('rclone');+ const installType = getInstallType();+ const args = [rcloneBinary, 'authorize', session.storageType];++ // For docker/server installs, don't try to open browser+ if (installType === 'docker' || installType === 'server') {+ args.push('--auth-no-open-browser');+ }++ let output = '';+ let errorOutput = '';++ // Set up auto-timeout+ const timeout = setTimeout(() => {+ if (session.process && !session.process.killed) {+ session.process.kill();+ }+ if (session.status === 'pending') {+ session.status = 'error';+ session.error = 'Authorization timed out after 5 minutes';+ }+ }, timeoutMs);++ const extractToken = (text: string): string | null => {+ const tokenMatch = text.match(/-+>\s*([\s\S]*?)\s*<-+/);+ if (tokenMatch && tokenMatch[1]) {+ const tokenJson = tokenMatch[1].trim();+ try {+ JSON.parse(tokenJson);+ return tokenJson;+ } catch {+ return null;+ }+ }+ return null;+ };++ runCommand(+ args,+ {},+ // onProgress (stdout)+ (data: Buffer) => {+ output += data.toString();+ console.log('[oauth] stdout:', data.toString());++ const token = extractToken(output);+ if (token) {+ session.status = 'success';+ session.token = token;+ }+ },+ // onError (stderr)+ (data: Buffer) => {+ const chunk = data.toString();+ errorOutput += chunk;+ console.log('[oauth] stderr:', chunk);++ // Extract auth URL from stderr (rclone prints it there)+ const urlMatch = chunk.match(/https?:\/\/127\.0\.0\.1:\d+\/auth\S*/);+ if (urlMatch && !session.authUrl) {+ session.authUrl = urlMatch[0];+ }+ },+ // onComplete (exit code)+ (code: number) => {+ clearTimeout(timeout);+ if (session.status === 'pending') {+ const token = extractToken(output);+ if (token) {+ session.status = 'success';+ session.token = token;+ return;+ }+ session.status = 'error';+ session.error = `rclone authorize exited with code ${code}`;+ }+ },+ // onSpawn (capture process ref)+ childProcess => {+ session.process = childProcess;+ }+ ).catch(err => {+ clearTimeout(timeout);+ // runCommand rejects on non-zero exit, but token may already be extracted+ if (session.status === 'pending') {+ const token = extractToken(output);+ if (token) {+ session.status = 'success';+ session.token = token;+ return;+ }+ session.status = 'error';+ session.error = err?.message || 'Authorization failed';+ }+ });+}diff --git a/frontend/src/components/Storage/AddStorage/AddStorage.module.scss b/frontend/src/components/Storage/AddStorage/AddStorage.module.scssindex 5a74c58..1a1c635 100644--- a/frontend/src/components/Storage/AddStorage/AddStorage.module.scss+++ b/frontend/src/components/Storage/AddStorage/AddStorage.module.scss@@ -166,3 +166,77 @@}}}++.oauthContainer {+ background-color: var(--background-color);+ border: 1px solid var(--line-color);+ border-radius: 6px;+ box-sizing: border-box;+ padding: 12px;+ word-break: break-all;+ &.success {+ background-color: var(--success-bg-color);+ border-color: var(--success-bg-color);+ color: var(--success-text-color);+ }+ &.error {+ background-color: var(--error-bg-color);+ border-color: var(--error-bg-color);+ color: var(--error-text-color);+ }+}++.oauthButton {+ display: flex;+ width: 100%;+ flex-direction: column;+ align-items: flex-end;+ .oauthAuthorizeBtn {+ display: flex;+ align-items: center;+ gap: 8px;+ padding: 10px 18px;+ font-size: 13px;+ font-weight: 600;+ color: #fff;+ background-color: var(--primary-color);+ border: none;+ border-radius: 6px;+ cursor: pointer;+ transition: background-color 0.2s;+ &:hover {+ opacity: 0.9;+ }+ }+}++.oauthInnerBtn {+ display: inline-flex;+ align-items: center;+ gap: 6px;+ padding: 6px 14px;+ font-size: 12px;+ font-weight: 500;+ color: var(--content-text-color);+ background-color: var(--content-background-color);+ border: none;+ border-radius: 6px;+ cursor: pointer;+ margin-top: 8px;+ &:hover {+ background-color: var(--primary-color);+ color: var(--primary-text-color);+ }+}++.oauthProgress {+ p {+ margin: 6px 0;+ font-size: 13px;+ line-height: 1.5;+ a {+ color: var(--primary-color);+ text-decoration: underline;+ }+ }+}diff --git a/frontend/src/components/Storage/StorageAuthSettings/StorageAuthSettings.tsx b/frontend/src/components/Storage/StorageAuthSettings/StorageAuthSettings.tsxindex 5d44f3b..ac34e69 100644--- a/frontend/src/components/Storage/StorageAuthSettings/StorageAuthSettings.tsx+++ b/frontend/src/components/Storage/StorageAuthSettings/StorageAuthSettings.tsx@@ -1,9 +1,10 @@-import { useEffect, useState } from 'react';+import { useCallback, useEffect, useRef, useState } from 'react';import { storageOptionField } from '../../../@types/storages';import Tristate from '../../common/form/Tristate/Tristate';import Icon from '../../common/Icon/Icon';import classes from '../AddStorage/AddStorage.module.scss';import StorageSettings from '../StorageSettings/StorageSettings';+import { startStorageAuthorize, getStorageAuthorizeStatus, cancelStorageAuthorize } from '../../../services/storage';interface StorageAuthSettingsProps {storageType: string;@@ -16,6 +17,8 @@ interface StorageAuthSettingsProps {onAuthTypeChange: (authType: string) => void;}+type OAuthStatus = 'idle' | 'authorizing' | 'success' | 'error';+const StorageAuthSettings = ({storageType,fields,@@ -29,6 +32,16 @@ const StorageAuthSettings = ({const [showAdvanced, setShowAdvanced] = useState(true);const [showOAuthDoc, setShowOAuthDoc] = useState(false);+ // OAuth auto-authorize state+ const [oauthStatus, setOauthStatus] = useState<OAuthStatus>('idle');+ const [authSessionId, setAuthSessionId] = useState<string | null>(null);+ const [authUrl, setAuthUrl] = useState<string | null>(null);+ const [authError, setAuthError] = useState<string | null>(null);+ const pollingRef = useRef<ReturnType<typeof setInterval> | null>(null);++ const installType = (window as any).plutonInstallType;+ const isDesktop = installType === 'binary' || installType === 'dev';+console.log('availableAuthTypes :', fields, authTypes, currentAuthType);useEffect(() => {@@ -37,6 +50,76 @@ const StorageAuthSettings = ({}}, [authTypes, currentAuthType, onAuthTypeChange]);+ // Cleanup polling on unmount+ useEffect(() => {+ return () => {+ if (pollingRef.current) {+ clearInterval(pollingRef.current);+ }+ };+ }, []);++ const stopPolling = useCallback(() => {+ if (pollingRef.current) {+ clearInterval(pollingRef.current);+ pollingRef.current = null;+ }+ }, []);++ const startOAuthAuthorize = useCallback(async () => {+ setOauthStatus('authorizing');+ setAuthUrl(null);+ setAuthError(null);++ try {+ const { sessionId } = await startStorageAuthorize(storageType);+ setAuthSessionId(sessionId);++ // Start polling every 2 seconds+ pollingRef.current = setInterval(async () => {+ try {+ const result = await getStorageAuthorizeStatus(sessionId);++ if (result.authUrl) {+ setAuthUrl(result.authUrl);+ }++ if (result.status === 'success' && result.token) {+ stopPolling();+ setOauthStatus('success');+ onUpdate({ ...settings, token: result.token });+ } else if (result.status === 'error') {+ stopPolling();+ setOauthStatus('error');+ setAuthError(result.error || 'Authorization failed');+ }+ } catch (err: any) {+ stopPolling();+ setOauthStatus('error');+ setAuthError(err?.message || 'Failed to check authorization status');+ }+ }, 2000);+ } catch (err: any) {+ setOauthStatus('error');+ setAuthError(err?.message || 'Failed to start authorization');+ }+ }, [storageType, settings, onUpdate, stopPolling]);++ const handleCancelAuthorize = useCallback(async () => {+ stopPolling();+ if (authSessionId) {+ try {+ await cancelStorageAuthorize(authSessionId);+ } catch {+ // Ignore cancel errors+ }+ }+ setOauthStatus('idle');+ setAuthSessionId(null);+ setAuthUrl(null);+ setAuthError(null);+ }, [authSessionId, stopPolling]);+return (<div className={classes.authSettings}><div@@ -67,14 +150,64 @@ const StorageAuthSettings = ({/></div>)}-<StorageSettingsfields={fields.filter((f) => f.authFieldType === currentAuthType)}settings={settings}onUpdate={(newSettings) => onUpdate(newSettings)}errors={errors}/>- {currentAuthType === 'oauth' && (++ {currentAuthType === 'oauth' && isDesktop && oauthStatus === 'idle' && (+ <div className={classes.oauthButton}>+ <button className={classes.oauthAuthorizeBtn} onClick={startOAuthAuthorize}>+ <Icon type={'key'} size={14} /> Authorize & Get Access Token+ </button>+ </div>+ )}++ {currentAuthType === 'oauth' && isDesktop && oauthStatus !== 'idle' && (+ <div className={`${classes.oauthContainer} ${classes[oauthStatus]}`}>+ {oauthStatus === 'authorizing' && (+ <div className={classes.oauthProgress}>+ <p>+ <strong>Waiting for authorization...</strong>+ <br />A browser window should have opened. Please authorize the connection in your browser.+ </p>+ {authUrl && (+ <p>+ If the browser didn't open automatically,{' '}+ <a href={authUrl} target="_blank" rel="noopener noreferrer">+ click here to authorize+ </a>+ .+ </p>+ )}+ <button className={classes.oauthInnerBtn} onClick={handleCancelAuthorize}>+ Cancel+ </button>+ </div>+ )}+ {oauthStatus === 'success' && (+ <div className={classes.oauthProgress}>+ <p>+ <Icon type={'check'} size={14} /> <strong>Authorization successful!</strong> Token has been automatically filled in.+ </p>+ </div>+ )}+ {oauthStatus === 'error' && (+ <div className={classes.oauthProgress}>+ <p>+ <strong>Authorization failed:</strong> {authError}+ </p>+ <button className={classes.oauthInnerBtn} onClick={startOAuthAuthorize}>+ <Icon type={'key'} size={14} /> Try Again+ </button>+ </div>+ )}+ </div>+ )}++ {currentAuthType === 'oauth' && !isDesktop && (<div className={classes.oauthDoc}><h4 onClick={() => setShowOAuthDoc(!showOAuthDoc)}><Icon type={'key'} size={14} /> Acquiring the OAuth Access Tokendiff --git a/frontend/src/services/storage.ts b/frontend/src/services/storage.tsindex fa1185f..730b48f 100644--- a/frontend/src/services/storage.ts+++ b/frontend/src/services/storage.ts@@ -198,3 +198,52 @@ export function useVerifyStorage() {},});}++// ── OAuth Authorization ─────────────────────────────────────────────+export async function startStorageAuthorize(type: string): Promise<{ sessionId: string }> {+ const header = new Headers({ 'Content-Type': 'application/json', Accept: 'application/json' });+ const res = await fetch(`${API_URL}/storages/authorize`, {+ method: 'POST',+ credentials: 'include',+ headers: header,+ body: JSON.stringify({ type }),+ });+ const data = await res.json();+ if (!data.success) {+ throw new Error(data.error);+ }+ return data.result;+}++export async function getStorageAuthorizeStatus(sessionId: string): Promise<{+ status: 'pending' | 'success' | 'error';+ token?: string;+ error?: string;+ authUrl?: string;+}> {+ const url = new URL(`${API_URL}/storages/authorize/status`);+ url.searchParams.set('sessionId', sessionId);+ const res = await fetch(url.toString(), {+ method: 'GET',+ credentials: 'include',+ });+ const data = await res.json();+ if (!data.success) {+ throw new Error(data.error);+ }+ return data.result;+}++export async function cancelStorageAuthorize(sessionId: string): Promise<void> {+ const header = new Headers({ 'Content-Type': 'application/json', Accept: 'application/json' });+ const res = await fetch(`${API_URL}/storages/authorize/cancel`, {+ method: 'POST',+ credentials: 'include',+ headers: header,+ body: JSON.stringify({ sessionId }),+ });+ const data = await res.json();+ if (!data.success) {+ throw new Error(data.error);+ }+}