Skip to content

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.ts
index 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.ts
index 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 dependencies
jest.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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.scss
index 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.tsx
index 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>
)}
-
<StorageSettings
fields={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 Token
diff --git a/frontend/src/services/storage.ts b/frontend/src/services/storage.ts
index 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);
+ }
+}