CLI: Implement auth status command

cli/commands/auth/login.ts

@@ -0,0 +1,96 @@
+import { password } from '@inquirer/prompts';
+import { __, sprintf } from '@wordpress/i18n';
+import { getAuthenticationUrl } from 'common/lib/oauth';
+import { AuthCommandLoggerAction as LoggerAction } from 'common/logger-actions';
+import { getUserInfo } from 'cli/lib/api';
+import {
+	getAuthToken,
+	lockAppdata,
+	readAppdata,
+	saveAppdata,
+	unlockAppdata,
+} from 'cli/lib/appdata';
+import { openBrowser } from 'cli/lib/browser';
+import { getAppLocale } from 'cli/lib/i18n';
+import { Logger, LoggerError } from 'cli/logger';
+import { StudioArgv } from 'cli/types';
+
+const CLI_REDIRECT_URI = `https://developer.wordpress.com/copy-oauth-token`;
+
+export async function runCommand(): Promise< void > {
+	const logger = new Logger< LoggerAction >();
+
+	try {
+		await getAuthToken();
+		logger.reportSuccess( __( 'Already authenticated with WordPress.com' ) );
+		return;
+	} catch ( error ) {
+		// Assume the token is invalid and proceed with authentication
+	}
+
+	logger.reportStart( LoggerAction.LOGIN, __( 'Opening browser for authentication…' ) );
+
+	const appLocale = await getAppLocale();
+	const authUrl = getAuthenticationUrl( appLocale, CLI_REDIRECT_URI );
+
+	try {
+		await openBrowser( authUrl );
+		logger.reportSuccess( __( 'Browser opened successfully' ) );
+	} catch ( error ) {
+		// If the browser fails to open, allow users to manually open the URL
+		const loggerError = new LoggerError(
+			sprintf( __( 'Failed to open browser. Please open the URL manually: %s' ), authUrl ),
+			error
+		);
+		logger.reportError( loggerError );
+	}
+
+	console.log(
+		__( 'Please complete authentication in your browser and paste the generated token here.' )
+	);
+	console.log( '' );
+
+	try {
+		const accessToken = await password( { message: __( 'Authentication token:' ) } );
+		const user = await getUserInfo( accessToken );
+
+		logger.reportSuccess( __( 'Authentication completed successfully!' ) );
+
+		try {
+			await lockAppdata();
+			const userData = await readAppdata();
+
+			const now = new Date();
+			const twoWeeksInSeconds = 2 * 7 * 24 * 60 * 60;
+
+			userData.authToken = {
+				accessToken,
+				id: user.ID,
+				email: user.email,
+				displayName: user.display_name,
+				expiresIn: twoWeeksInSeconds,
+				expirationTime: now.getTime() + twoWeeksInSeconds * 1000,
+			};
+
+			await saveAppdata( userData );
+		} finally {
+			await unlockAppdata();
+		}
+	} catch ( error ) {
+		if ( error instanceof LoggerError ) {
+			logger.reportError( error );
+		} else {
+			logger.reportError( new LoggerError( __( 'Authentication failed' ), error ) );
+		}
+	}
+}
+
+export const registerCommand = ( yargs: StudioArgv ) => {
+	return yargs.command( {
+		command: 'login',
+		describe: __( 'Log in to WordPress.com' ),
+		handler: async () => {
+			await runCommand();
+		},
+	} );
+};

cli/commands/auth/logout.ts

@@ -0,0 +1,55 @@
+import { __ } from '@wordpress/i18n';
+import { AuthCommandLoggerAction as LoggerAction } from 'common/logger-actions';
+import { revokeAuthToken } from 'cli/lib/api';
+import {
+	readAppdata,
+	saveAppdata,
+	lockAppdata,
+	unlockAppdata,
+	getAuthToken,
+} from 'cli/lib/appdata';
+import { Logger, LoggerError } from 'cli/logger';
+import { StudioArgv } from 'cli/types';
+
+export async function runCommand(): Promise< void > {
+	const logger = new Logger< LoggerAction >();
+
+	logger.reportStart( LoggerAction.LOGOUT, __( 'Logging out…' ) );
+	let token: Awaited< ReturnType< typeof getAuthToken > >;
+
+	try {
+		token = await getAuthToken();
+	} catch ( error ) {
+		logger.reportSuccess( __( 'Already logged out' ) );
+		return;
+	}
+
+	try {
+		await revokeAuthToken( token.accessToken );
+
+		await lockAppdata();
+		const userData = await readAppdata();
+		delete userData.authToken;
+		await saveAppdata( userData );
+
+		logger.reportSuccess( __( 'Successfully logged out' ) );
+	} catch ( error ) {
+		if ( error instanceof LoggerError ) {
+			logger.reportError( error );
+		} else {
+			logger.reportError( new LoggerError( __( 'Failed to log out' ), error ) );
+		}
+	} finally {
+		await unlockAppdata();
+	}
+}
+
+export const registerCommand = ( yargs: StudioArgv ) => {
+	return yargs.command( {
+		command: 'logout',
+		describe: __( 'Log out and clear WordPress.com authentication' ),
+		handler: async () => {
+			await runCommand();
+		},
+	} );
+};

cli/commands/auth/status.ts

@@ -0,0 +1,43 @@
+import { __, sprintf } from '@wordpress/i18n';
+import { AuthCommandLoggerAction as LoggerAction } from 'common/logger-actions';
+import { getUserInfo } from 'cli/lib/api';
+import { getAuthToken } from 'cli/lib/appdata';
+import { Logger, LoggerError } from 'cli/logger';
+import { StudioArgv } from 'cli/types';
+
+export async function runCommand(): Promise< void > {
+	const logger = new Logger< LoggerAction >();
+
+	logger.reportStart( LoggerAction.STATUS_CHECK, __( 'Checking authentication status…' ) );
+	let token: Awaited< ReturnType< typeof getAuthToken > >;
+
+	try {
+		token = await getAuthToken();
+	} catch ( error ) {
+		logger.reportError( new LoggerError( __( 'Authentication token is invalid or expired' ) ) );
+		return;
+	}
+
+	try {
+		const userData = await getUserInfo( token.accessToken );
+		logger.reportSuccess(
+			sprintf( __( 'Successfully authenticated with WordPress.com as `%s`' ), userData.username )
+		);
+	} catch ( error ) {
+		if ( error instanceof LoggerError ) {
+			logger.reportError( error );
+		} else {
+			logger.reportError( new LoggerError( __( 'Failed to check authentication status' ), error ) );
+		}
+	}
+}
+
+export const registerCommand = ( yargs: StudioArgv ) => {
+	return yargs.command( {
+		command: 'status',
+		describe: __( 'Check authentication status' ),
+		handler: async () => {
+			await runCommand();
+		},
+	} );
+};

cli/commands/auth/tests/login.test.ts

@@ -0,0 +1,185 @@
+import { password } from '@inquirer/prompts';
+import { getAuthenticationUrl } from 'common/lib/oauth';
+import { getUserInfo } from 'cli/lib/api';
+import {
+	getAuthToken,
+	lockAppdata,
+	readAppdata,
+	saveAppdata,
+	unlockAppdata,
+} from 'cli/lib/appdata';
+import { openBrowser } from 'cli/lib/browser';
+import { getAppLocale } from 'cli/lib/i18n';
+import { Logger, LoggerError } from 'cli/logger';
+
+jest.mock( '@inquirer/prompts' );
+jest.mock( 'common/lib/oauth' );
+jest.mock( 'cli/lib/api' );
+jest.mock( 'cli/lib/appdata', () => ( {
+	...jest.requireActual( 'cli/lib/appdata' ),
+	lockAppdata: jest.fn(),
+	readAppdata: jest.fn(),
+	saveAppdata: jest.fn(),
+	unlockAppdata: jest.fn(),
+	getAuthToken: jest.fn(),
+} ) );
+jest.mock( 'cli/lib/browser' );
+jest.mock( 'cli/lib/i18n' );
+jest.mock( 'cli/logger' );
+
+describe( 'Auth Login Command', () => {
+	const mockAccessToken = 'mock-access-token-12345';
+	const mockAuthUrl = 'https://public-api.wordpress.com/oauth2/authorize?client_id=123';
+	const mockUserData = {
+		ID: 12345,
+		email: '[email protected]',
+		display_name: 'Test User',
+	};
+	const mockAppdata = {
+		authToken: {
+			accessToken: 'existing-token',
+			id: 999,
+			email: '[email protected]',
+			displayName: 'Existing User',
+			expiresIn: 1209600,
+			expirationTime: Date.now() + 1209600000,
+		},
+	};
+
+	let mockLogger: {
+		reportStart: jest.Mock;
+		reportSuccess: jest.Mock;
+		reportError: jest.Mock;
+		reportKeyValuePair: jest.Mock;
+	};
+
+	beforeEach( () => {
+		jest.clearAllMocks();
+
+		mockLogger = {
+			reportStart: jest.fn(),
+			reportSuccess: jest.fn(),
+			reportError: jest.fn(),
+			reportKeyValuePair: jest.fn(),
+		};
+
+		( Logger as jest.Mock ).mockReturnValue( mockLogger );
+		( getAuthenticationUrl as jest.Mock ).mockReturnValue( mockAuthUrl );
+		( getAppLocale as jest.Mock ).mockResolvedValue( 'en' );
+		( getUserInfo as jest.Mock ).mockResolvedValue( mockUserData );
+		( openBrowser as jest.Mock ).mockResolvedValue( undefined );
+		( password as jest.Mock ).mockResolvedValue( mockAccessToken );
+		( readAppdata as jest.Mock ).mockResolvedValue( mockAppdata );
+		( getAuthToken as jest.Mock ).mockRejectedValue( new Error( 'Mock error' ) );
+		( lockAppdata as jest.Mock ).mockResolvedValue( undefined );
+		( unlockAppdata as jest.Mock ).mockResolvedValue( undefined );
+		( saveAppdata as jest.Mock ).mockResolvedValue( undefined );
+	} );
+
+	afterEach( () => {
+		jest.restoreAllMocks();
+	} );
+
+	it( 'should skip login if already authenticated', async () => {
+		( getAuthToken as jest.Mock ).mockResolvedValue( mockAppdata.authToken );
+
+		const { runCommand } = await import( '../login' );
+		await runCommand();
+
+		expect( openBrowser ).not.toHaveBeenCalled();
+		expect( password ).not.toHaveBeenCalled();
+	} );
+
+	it( 'should complete the login process successfully', async () => {
+		const { runCommand } = await import( '../login' );
+		await runCommand();
+
+		expect( getAuthenticationUrl ).toHaveBeenCalledWith(
+			'en',
+			'https://developer.wordpress.com/copy-oauth-token'
+		);
+		expect( openBrowser ).toHaveBeenCalledWith( mockAuthUrl );
+		expect( password ).toHaveBeenCalledWith( {
+			message: 'Authentication token:',
+		} );
+		expect( getUserInfo ).toHaveBeenCalledWith( mockAccessToken );
+		expect( lockAppdata ).toHaveBeenCalled();
+		expect( saveAppdata ).toHaveBeenCalledWith( {
+			authToken: {
+				accessToken: mockAccessToken,
+				id: mockUserData.ID,
+				email: mockUserData.email,
+				displayName: mockUserData.display_name,
+				expiresIn: expect.any( Number ),
+				expirationTime: expect.any( Number ),
+			},
+		} );
+		expect( unlockAppdata ).toHaveBeenCalled();
+	} );
+
+	it( 'should proceed with login if existing token is invalid', async () => {
+		const { runCommand } = await import( '../login' );
+		await runCommand();
+
+		expect( openBrowser ).toHaveBeenCalled();
+		expect( password ).toHaveBeenCalled();
+	} );
+
+	it( 'should handle browser open failure', async () => {
+		const browserError = new LoggerError( 'Failed to open browser' );
+		( openBrowser as jest.Mock ).mockRejectedValue( browserError );
+
+		const { runCommand } = await import( '../login' );
+		await runCommand();
+
+		expect( password ).toHaveBeenCalled();
+	} );
+
+	it( 'should handle API error when fetching user info', async () => {
+		const apiError = new LoggerError( 'Failed to fetch user info' );
+		( getUserInfo as jest.Mock ).mockRejectedValue( apiError );
+
+		const { runCommand } = await import( '../login' );
+		await runCommand();
+
+		expect( mockLogger.reportError ).toHaveBeenCalled();
+		expect( mockLogger.reportError ).toHaveBeenCalledWith( expect.any( LoggerError ) );
+		expect( getUserInfo ).toHaveBeenCalled();
+	} );
+
+	it( 'should unlock appdata even if save fails', async () => {
+		const saveError = new Error( 'Failed to save' );
+		( saveAppdata as jest.Mock ).mockRejectedValue( saveError );
+
+		const { runCommand } = await import( '../login' );
+		await runCommand();
+
+		expect( mockLogger.reportError ).toHaveBeenCalled();
+		expect( mockLogger.reportError ).toHaveBeenCalledWith( expect.any( LoggerError ) );
+		expect( lockAppdata ).toHaveBeenCalled();
+		expect( unlockAppdata ).toHaveBeenCalled();
+	} );
+
+	it( 'should handle lock appdata failure', async () => {
+		const lockError = new Error( 'Failed to lock' );
+		( lockAppdata as jest.Mock ).mockRejectedValue( lockError );
+
+		const { runCommand } = await import( '../login' );
+		await runCommand();
+
+		expect( mockLogger.reportError ).toHaveBeenCalled();
+		expect( mockLogger.reportError ).toHaveBeenCalledWith( expect.any( LoggerError ) );
+	} );
+
+	it( 'should use provided locale', async () => {
+		( getAppLocale as jest.Mock ).mockResolvedValue( 'fr' );
+
+		const { runCommand } = await import( '../login' );
+		await runCommand();
+
+		expect( getAuthenticationUrl ).toHaveBeenCalledWith(
+			'fr',
+			'https://developer.wordpress.com/copy-oauth-token'
+		);
+	} );
+} );