agent-messenger 2.17.0 → 2.19.0

package/src/platforms/webex/commands/auth.ts

@@ -2,6 +2,7 @@ import { Command } from 'commander'
 
 import { collectBrowserProfileOption } from '@/shared/chromium'
 import { handleError } from '@/shared/utils/error-handler'
+import { isInteractive } from '@/shared/utils/interactive'
 import { formatOutput } from '@/shared/utils/output'
 import { info, debug } from '@/shared/utils/stderr'
 
@@ -43,12 +44,15 @@ async function resolveClientCredentials(options: {
   return getWebexAppCredentials()
 }
 
-export async function loginAction(options: {
+interface LoginOptions {
   token?: string
+  deviceCode?: string
   clientId?: string
   clientSecret?: string
   pretty?: boolean
-}): Promise<void> {
+}
+
+export async function loginAction(options: LoginOptions): Promise<void> {
   try {
     const credManager = new WebexCredentialManager()
 
@@ -73,6 +77,16 @@ export async function loginAction(options: {
       return
     }
 
+    if (options.deviceCode) {
+      await finishDeviceGrant(credManager, options)
+      return
+    }
+
+    if (!isInteractive()) {
+      await startNonInteractiveDeviceGrant(credManager, options)
+      return
+    }
+
     const { clientId, clientSecret } = await resolveClientCredentials(options)
 
     const device = await credManager.requestDeviceCode(clientId)
@@ -110,6 +124,81 @@ export async function loginAction(options: {
   }
 }
 
+async function startNonInteractiveDeviceGrant(
+  credManager: WebexCredentialManager,
+  options: LoginOptions,
+): Promise<void> {
+  const { clientId } = await resolveClientCredentials(options)
+  const device = await credManager.requestDeviceCode(clientId)
+  const expiresAt = Date.now() + device.expiresIn * 1000
+
+  console.log(
+    formatOutput(
+      {
+        next_action: 'authorize_in_browser',
+        verification_uri: device.verificationUri,
+        verification_uri_complete: device.verificationUriComplete,
+        user_code: device.userCode,
+        device_code: device.deviceCode,
+        expires_at: expiresAt,
+        message:
+          'Show the user `verification_uri` and `user_code` (or just `verification_uri_complete`) and ask them to approve access in any browser. After they approve, run `agent-webex auth login --device-code <device_code>` to retrieve the token. The device code expires at `expires_at`. If you passed `--client-id`/`--client-secret`, pass them again on the second call.',
+      },
+      options.pretty,
+    ),
+  )
+  process.exit(0)
+}
+
+async function finishDeviceGrant(credManager: WebexCredentialManager, options: LoginOptions): Promise<void> {
+  const { clientId, clientSecret } = await resolveClientCredentials(options)
+  const result = await credManager.exchangeDeviceCode(options.deviceCode!, clientId, clientSecret)
+
+  if (result.status === 'success') {
+    await credManager.saveConfig({ ...result.config, clientId, clientSecret, tokenType: 'oauth' })
+    const client = await new WebexClient().login({ token: result.config.accessToken })
+    const person = await client.testAuth()
+    console.log(
+      formatOutput(
+        {
+          authenticated: true,
+          user: { id: person.id, displayName: person.displayName, emails: person.emails },
+        },
+        options.pretty,
+      ),
+    )
+    return
+  }
+
+  if (result.status === 'pending') {
+    console.log(
+      formatOutput(
+        {
+          next_action: 'still_pending',
+          device_code: options.deviceCode,
+          message:
+            'User has not approved access yet. Confirm with the user that they completed authorization in the browser, then run `agent-webex auth login --device-code <device_code>` again to retry.',
+        },
+        options.pretty,
+      ),
+    )
+    process.exit(0)
+    return
+  }
+
+  console.log(
+    formatOutput(
+      {
+        next_action: 'restart',
+        error: result.status === 'expired' ? 'Device code expired.' : `Device code exchange failed: ${result.message}`,
+        message: 'This device code is no longer valid. Run `agent-webex auth login` to start a new login.',
+      },
+      options.pretty,
+    ),
+  )
+  process.exit(1)
+}
+
 export async function statusAction(options: { pretty?: boolean }): Promise<void> {
   try {
     const credManager = new WebexCredentialManager()
@@ -276,8 +365,18 @@ export const authCommand = new Command('auth')
   .description('Authentication commands')
   .addCommand(
     new Command('login')
-      .description('Login to Webex')
+      .description(
+        'Log in to Webex. In a TTY this opens a browser and waits for approval. ' +
+          'When non-interactive (AI agents, CI/CD): first call starts the OAuth Device Grant flow ' +
+          'and returns a verification URL, user code, and device code. After the user approves in a ' +
+          'browser, call again with --device-code to exchange it for a token. Pass --token for ' +
+          'fully unattended auth.',
+      )
       .option('--token <token>', 'Use a bot token or personal access token directly')
+      .option(
+        '--device-code <code>',
+        'OAuth Device Grant code returned from a previous non-interactive `auth login` call',
+      )
       .option('--client-id <id>', 'Webex Integration client ID')
       .option('--client-secret <secret>', 'Webex Integration client secret')
       .option('--pretty', 'Pretty print JSON output')

package/src/platforms/webex/commands/member.test.ts

@@ -1,14 +1,9 @@
 import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
 
-import { WebexError } from '../types'
-
-const mockHandleError = mock((err: Error) => {
-  throw err
-})
+import * as errorHandler from '@/shared/utils/error-handler'
 
-mock.module('@/shared/utils/error-handler', () => ({
-  handleError: mockHandleError,
-}))
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
 
 const mockMembers = [
   {
@@ -32,30 +27,29 @@ const mockMembers = [
 ]
 
 const mockListMemberships = mock(() => Promise.resolve(mockMembers))
-const mockLogin = mock(() => Promise.resolve({ listMemberships: mockListMemberships }))
-
-mock.module('../client', () => ({
-  WebexClient: class {
-    login = mockLogin
-  },
-}))
 
 import { listAction } from './member'
 
 describe('member commands', () => {
   let consoleSpy: ReturnType<typeof spyOn>
+  let loginSpy: ReturnType<typeof spyOn>
+  let handleErrorSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
     mockListMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMembers))
-    mockLogin.mockReset().mockImplementation(() => Promise.resolve({ listMemberships: mockListMemberships }))
-    mockHandleError.mockReset().mockImplementation((err: Error) => {
+    handleErrorSpy = spyOn(errorHandler, 'handleError').mockImplementation((err: Error) => {
       throw err
     })
 
+    loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(
+      Object.assign(new WebexClient(), { listMemberships: mockListMemberships }),
+    )
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
   })
 
   afterEach(() => {
+    loginSpy.mockRestore()
+    handleErrorSpy.mockRestore()
     consoleSpy.mockRestore()
   })
 
@@ -92,13 +86,13 @@ describe('member commands', () => {
   })
 
   it('throws when not authenticated', async () => {
-    mockLogin.mockImplementation(async () => {
+    loginSpy.mockImplementation(async () => {
       throw new WebexError('No Webex credentials found.', 'no_credentials')
     })
 
     await expect(listAction('room-1', {})).rejects.toThrow('No Webex credentials found.')
 
-    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
   })
 
   it('throws on API error', async () => {
@@ -108,6 +102,6 @@ describe('member commands', () => {
 
     await expect(listAction('room-1', {})).rejects.toThrow('API failure')
 
-    expect(mockHandleError).toHaveBeenCalledWith(expect.any(Error))
+    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(Error))
   })
 })

package/src/platforms/webex/commands/message.test.ts

@@ -1,14 +1,9 @@
 import { afterEach, beforeEach, expect, mock, spyOn, it } from 'bun:test'
 
-import { WebexError } from '../types'
-
-const mockHandleError = mock((err: Error) => {
-  throw err
-})
+import * as errorHandler from '@/shared/utils/error-handler'
 
-mock.module('@/shared/utils/error-handler', () => ({
-  handleError: mockHandleError,
-}))
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
 
 const mockMessage = {
   id: 'msg_123',
@@ -46,17 +41,11 @@ const mockClient = {
   editMessage: mockEditMessage,
 }
 
-const mockLogin = mock(() => Promise.resolve(mockClient))
-
-mock.module('../client', () => ({
-  WebexClient: class {
-    login = mockLogin
-  },
-}))
-
 import { deleteAction, dmAction, editAction, getAction, listAction, sendAction } from './message'
 
 let consoleLogSpy: ReturnType<typeof spyOn>
+let loginSpy: ReturnType<typeof spyOn>
+let handleErrorSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
   mockSendMessage.mockReset().mockImplementation(() => Promise.resolve(mockMessage))
@@ -65,15 +54,17 @@ beforeEach(() => {
   mockGetMessage.mockReset().mockImplementation(() => Promise.resolve(mockMessage))
   mockDeleteMessage.mockReset().mockImplementation(() => Promise.resolve(undefined))
   mockEditMessage.mockReset().mockImplementation(() => Promise.resolve({ ...mockMessage, text: 'Updated message' }))
-  mockLogin.mockReset().mockImplementation(() => Promise.resolve(mockClient))
-  mockHandleError.mockReset().mockImplementation((err: Error) => {
+  handleErrorSpy = spyOn(errorHandler, 'handleError').mockImplementation((err: Error) => {
     throw err
   })
 
+  loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(Object.assign(new WebexClient(), mockClient))
   consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
 })
 
 afterEach(() => {
+  loginSpy.mockRestore()
+  handleErrorSpy.mockRestore()
   consoleLogSpy.mockRestore()
 })
 
@@ -97,13 +88,13 @@ it('passes markdown option when --markdown flag is set on send', async () => {
 })
 
 it('throws when not authenticated on send', async () => {
-  mockLogin.mockImplementation(async () => {
+  loginSpy.mockImplementation(async () => {
     throw new WebexError('No Webex credentials found.', 'no_credentials')
   })
 
   await expect(sendAction('space_456', 'Hello', { pretty: false })).rejects.toThrow('No Webex credentials found.')
 
-  expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+  expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
 })
 
 it('calls sendDirectMessage with email and text', async () => {

package/src/platforms/webex/commands/snapshot.test.ts

@@ -1,14 +1,9 @@
 import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
 
-import { WebexError } from '../types'
-
-const mockHandleError = mock((err: Error) => {
-  throw err
-})
+import * as errorHandler from '@/shared/utils/error-handler'
 
-mock.module('@/shared/utils/error-handler', () => ({
-  handleError: mockHandleError,
-}))
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
 
 const mockSpaces = [
   {
@@ -51,31 +46,27 @@ const mockClient = {
   listMyMemberships: mockListMyMemberships,
 }
 
-const mockLogin = mock(() => Promise.resolve(mockClient))
-
-mock.module('../client', () => ({
-  WebexClient: class {
-    login = mockLogin
-  },
-}))
-
 import { snapshotAction } from './snapshot'
 
 describe('snapshot command', () => {
   let consoleSpy: ReturnType<typeof spyOn>
+  let loginSpy: ReturnType<typeof spyOn>
+  let handleErrorSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
     mockListSpaces.mockReset().mockImplementation(() => Promise.resolve(mockSpaces as any))
     mockListMyMemberships.mockReset().mockImplementation(() => Promise.resolve(mockMyMemberships as any))
-    mockLogin.mockReset().mockImplementation(() => Promise.resolve(mockClient))
-    mockHandleError.mockReset().mockImplementation((err: Error) => {
+    handleErrorSpy = spyOn(errorHandler, 'handleError').mockImplementation((err: Error) => {
       throw err
     })
 
+    loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(Object.assign(new WebexClient(), mockClient))
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
   })
 
   afterEach(() => {
+    loginSpy.mockRestore()
+    handleErrorSpy.mockRestore()
     consoleSpy.mockRestore()
   })
 
@@ -113,12 +104,12 @@ describe('snapshot command', () => {
   })
 
   it('throws when not authenticated', async () => {
-    mockLogin.mockImplementation(async () => {
+    loginSpy.mockImplementation(async () => {
       throw new WebexError('No Webex credentials found.', 'no_credentials')
     })
 
     await expect(snapshotAction({})).rejects.toThrow('No Webex credentials found.')
 
-    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
   })
 })

package/src/platforms/webex/commands/space.test.ts

@@ -1,14 +1,9 @@
 import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:test'
 
-import { WebexError } from '../types'
-
-const mockHandleError = mock((err: Error) => {
-  throw err
-})
+import * as errorHandler from '@/shared/utils/error-handler'
 
-mock.module('@/shared/utils/error-handler', () => ({
-  handleError: mockHandleError,
-}))
+import { WebexClient } from '../client'
+import { WebexError } from '../types'
 
 const mockSpaces = [
   {
@@ -44,32 +39,29 @@ const mockSpace = {
 
 const mockListSpaces = mock(() => Promise.resolve(mockSpaces))
 const mockGetSpace = mock(() => Promise.resolve(mockSpace))
-const mockLogin = mock(() => Promise.resolve({ listSpaces: mockListSpaces, getSpace: mockGetSpace }))
-
-mock.module('../client', () => ({
-  WebexClient: class {
-    login = mockLogin
-  },
-}))
 
 import { infoAction, listAction } from './space'
 
 let consoleLogSpy: ReturnType<typeof spyOn>
+let loginSpy: ReturnType<typeof spyOn>
+let handleErrorSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
   mockListSpaces.mockReset().mockImplementation(() => Promise.resolve(mockSpaces))
   mockGetSpace.mockReset().mockImplementation(() => Promise.resolve(mockSpace))
-  mockLogin
-    .mockReset()
-    .mockImplementation(() => Promise.resolve({ listSpaces: mockListSpaces, getSpace: mockGetSpace }))
-  mockHandleError.mockReset().mockImplementation((err: Error) => {
+  handleErrorSpy = spyOn(errorHandler, 'handleError').mockImplementation((err: Error) => {
     throw err
   })
 
+  loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(
+    Object.assign(new WebexClient(), { listSpaces: mockListSpaces, getSpace: mockGetSpace }),
+  )
   consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
 })
 
 afterEach(() => {
+  loginSpy.mockRestore()
+  handleErrorSpy.mockRestore()
   consoleLogSpy.mockRestore()
 })
 
@@ -138,14 +130,14 @@ describe('listAction', () => {
   })
 
   it('throws when not authenticated', async () => {
-    mockLogin.mockImplementation(async () => {
+    loginSpy.mockImplementation(async () => {
       throw new WebexError('No Webex credentials found.', 'no_credentials')
     })
 
     await expect(listAction({})).rejects.toThrow('No Webex credentials found.')
 
     expect(mockListSpaces).not.toHaveBeenCalled()
-    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
   })
 })
 
@@ -201,13 +193,13 @@ describe('infoAction', () => {
   })
 
   it('throws when not authenticated', async () => {
-    mockLogin.mockImplementation(async () => {
+    loginSpy.mockImplementation(async () => {
       throw new WebexError('No Webex credentials found.', 'no_credentials')
     })
 
     await expect(infoAction('space-1', {})).rejects.toThrow('No Webex credentials found.')
 
     expect(mockGetSpace).not.toHaveBeenCalled()
-    expect(mockHandleError).toHaveBeenCalledWith(expect.any(WebexError))
+    expect(handleErrorSpy).toHaveBeenCalledWith(expect.any(WebexError))
   })
 })

package/src/platforms/webex/commands/whoami.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, expect, spyOn, it } from 'bun:test'
 
-import * as clientModule from '../client'
+import { WebexClient } from '../client'
 import { WebexError } from '../types'
 import { whoamiCommand } from './whoami'
 
@@ -17,27 +17,21 @@ const mockUser = {
   created: '2024-01-01T00:00:00.000Z',
 }
 
-const makeFakeClient = () => ({
-  login: async function (this: unknown) {
-    return this
-  },
-  testAuth: async () => mockUser,
-})
-
-let webexClientSpy: ReturnType<typeof spyOn>
+let loginSpy: ReturnType<typeof spyOn>
+let testAuthSpy: ReturnType<typeof spyOn>
 let consoleLogSpy: ReturnType<typeof spyOn>
 let processExitSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
-  webexClientSpy = spyOn(clientModule, 'WebexClient').mockImplementation(
-    makeFakeClient as unknown as typeof clientModule.WebexClient,
-  )
+  loginSpy = spyOn(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+  testAuthSpy = spyOn(WebexClient.prototype, 'testAuth').mockResolvedValue(mockUser)
   consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
   processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
 })
 
 afterEach(() => {
-  webexClientSpy?.mockRestore()
+  loginSpy?.mockRestore()
+  testAuthSpy?.mockRestore()
   consoleLogSpy?.mockRestore()
   processExitSpy?.mockRestore()
 })
@@ -102,15 +96,7 @@ it('whoami outputs pretty-printed JSON when --pretty flag is passed', async () =
 
 it('whoami exits with code 1 when not authenticated', async () => {
   // given: no credentials
-  webexClientSpy.mockImplementation(
-    () =>
-      ({
-        login: async () => {
-          throw new WebexError('No Webex credentials found.', 'no_credentials')
-        },
-        testAuth: async () => mockUser,
-      }) as unknown as clientModule.WebexClient,
-  )
+  loginSpy.mockRejectedValue(new WebexError('No Webex credentials found.', 'no_credentials'))
 
   // when: running whoami
   await whoamiCommand.parseAsync([], { from: 'user' })

package/src/platforms/webex/credential-manager.test.ts

@@ -373,4 +373,82 @@ describe('WebexCredentialManager', () => {
     expect(loaded?.clientId).toBeUndefined()
     expect(loaded?.clientSecret).toBeUndefined()
   })
+
+  describe('exchangeDeviceCode', () => {
+    let originalFetch: typeof globalThis.fetch
+
+    beforeEach(() => {
+      originalFetch = globalThis.fetch
+    })
+
+    afterEach(() => {
+      globalThis.fetch = originalFetch
+    })
+
+    it('returns success with config on 200', async () => {
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response(JSON.stringify({ access_token: 'at', refresh_token: 'rt', expires_in: 3600 }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+          }),
+        ),
+      ) as unknown as typeof globalThis.fetch
+
+      const result = await credManager.exchangeDeviceCode('dc', 'cid', 'csec')
+      expect(result.status).toBe('success')
+      if (result.status === 'success') {
+        expect(result.config.accessToken).toBe('at')
+        expect(result.config.refreshToken).toBe('rt')
+      }
+    })
+
+    it('returns pending on 428', async () => {
+      globalThis.fetch = mock(() =>
+        Promise.resolve(new Response('', { status: 428 })),
+      ) as unknown as typeof globalThis.fetch
+      const result = await credManager.exchangeDeviceCode('dc', 'cid', 'csec')
+      expect(result.status).toBe('pending')
+    })
+
+    it('returns pending when error description includes authorization_pending', async () => {
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response(JSON.stringify({ errors: [{ description: 'authorization_pending' }] }), {
+            status: 400,
+            headers: { 'Content-Type': 'application/json' },
+          }),
+        ),
+      ) as unknown as typeof globalThis.fetch
+      const result = await credManager.exchangeDeviceCode('dc', 'cid', 'csec')
+      expect(result.status).toBe('pending')
+    })
+
+    it('returns expired when error description signals expiry', async () => {
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response(JSON.stringify({ errors: [{ description: 'expired_token' }] }), {
+            status: 400,
+            headers: { 'Content-Type': 'application/json' },
+          }),
+        ),
+      ) as unknown as typeof globalThis.fetch
+      const result = await credManager.exchangeDeviceCode('dc', 'cid', 'csec')
+      expect(result.status).toBe('expired')
+    })
+
+    it('returns error on other failures', async () => {
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response(JSON.stringify({ errors: [{ description: 'access_denied' }] }), {
+            status: 403,
+            headers: { 'Content-Type': 'application/json' },
+          }),
+        ),
+      ) as unknown as typeof globalThis.fetch
+      const result = await credManager.exchangeDeviceCode('dc', 'cid', 'csec')
+      expect(result.status).toBe('error')
+      if (result.status === 'error') expect(result.message).toContain('access_denied')
+    })
+  })
 })

package/src/platforms/webex/credential-manager.ts

@@ -212,6 +212,65 @@ export class WebexCredentialManager {
     throw new Error('Device authorization timed out')
   }
 
+  async exchangeDeviceCode(
+    deviceCode: string,
+    clientId: string,
+    clientSecret?: string,
+  ): Promise<
+    | { status: 'success'; config: Pick<WebexConfig, 'accessToken' | 'refreshToken' | 'expiresAt'> }
+    | { status: 'pending' }
+    | { status: 'expired' }
+    | { status: 'error'; message: string }
+  > {
+    const basicAuth = btoa(`${clientId}:${clientSecret ?? ''}`)
+
+    const response = await fetch(OAUTH_DEVICE_TOKEN_URL, {
+      method: 'POST',
+      headers: {
+        Authorization: `Basic ${basicAuth}`,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: new URLSearchParams({
+        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+        device_code: deviceCode,
+        client_id: clientId,
+      }),
+    })
+
+    if (response.ok) {
+      const data = (await response.json()) as {
+        access_token: string
+        refresh_token: string
+        expires_in: number
+      }
+      return {
+        status: 'success',
+        config: {
+          accessToken: data.access_token,
+          refreshToken: data.refresh_token,
+          expiresAt: Date.now() + data.expires_in * 1000,
+        },
+      }
+    }
+
+    if (response.status === 428) return { status: 'pending' }
+
+    const errorBody = (await response.json().catch(() => null)) as {
+      errors?: Array<{ description: string }>
+    } | null
+    const errorDesc = errorBody?.errors?.[0]?.description ?? ''
+
+    if (errorDesc.includes('authorization_pending') || errorDesc.includes('slow_down')) {
+      return { status: 'pending' }
+    }
+
+    if (errorDesc.includes('expired_token') || errorDesc.includes('expired')) {
+      return { status: 'expired' }
+    }
+
+    return { status: 'error', message: errorDesc || `http_${response.status}` }
+  }
+
   async clearCredentials(): Promise<void> {
     if (existsSync(this.credentialsPath)) {
       await rm(this.credentialsPath)