agent-messenger 2.27.2 → 2.29.0

package/src/platforms/instagram/commands/auth.test.ts

@@ -3,6 +3,7 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:te
 const originalConsoleLog = console.log
 import type { Command } from 'commander'
 
+import { InstagramClient } from '../client'
 import { InstagramCredentialManager } from '../credential-manager'
 
 const mockGetAccount = mock(() => Promise.resolve(null))
@@ -10,7 +11,7 @@ const mockListAccounts = mock(() => Promise.resolve([]))
 const mockSetCurrent = mock(() => Promise.resolve(true))
 const mockRemoveAccount = mock(() => Promise.resolve(true))
 
-import { authCommand } from './auth'
+import { authCommand, sanitizePassword } from './auth'
 
 function resetCommandState(cmd: Command): void {
   for (const sub of cmd.commands) {
@@ -216,4 +217,179 @@ describe('auth commands', () => {
       expect(output.error).toContain('missing_account')
     })
   })
+
+  describe('sanitizePassword', () => {
+    it('preserves leading and trailing whitespace', () => {
+      expect(sanitizePassword('  pass word  ')).toBe('  pass word  ')
+      expect(sanitizePassword('\tpw\t')).toBe('\tpw\t')
+    })
+
+    it('preserves internal characters exactly', () => {
+      expect(sanitizePassword('p@$$ w0rd!#')).toBe('p@$$ w0rd!#')
+    })
+
+    it('strips only a trailing carriage return', () => {
+      expect(sanitizePassword('secret\r')).toBe('secret')
+      expect(sanitizePassword('sec\rret')).toBe('sec\rret')
+    })
+
+    it('returns undefined for empty input', () => {
+      expect(sanitizePassword('')).toBeUndefined()
+      expect(sanitizePassword('\r')).toBeUndefined()
+    })
+
+    it('keeps a whitespace-only password (not treated as empty)', () => {
+      expect(sanitizePassword('   ')).toBe('   ')
+    })
+  })
+
+  describe('login-email', () => {
+    it('redeems uid/token non-interactively and saves the account', async () => {
+      const oneClickSpy = spyOn(InstagramClient.prototype, 'oneClickLogin').mockResolvedValue({ userId: '4242' })
+      const setSessionPathSpy = spyOn(InstagramClient.prototype, 'setSessionPath').mockImplementation(() => {})
+      const ensurePathsSpy = spyOn(InstagramCredentialManager.prototype, 'ensureAccountPaths').mockResolvedValue({
+        account_dir: '/tmp/x',
+        session_path: '/tmp/x/session.json',
+      })
+      const setAccountSpy = spyOn(InstagramCredentialManager.prototype, 'setAccount').mockResolvedValue(undefined)
+
+      await authCommand.parseAsync(
+        ['login-email', '--username', 'alice', '--uid', 'ENCODED_UID', '--token', 'NONCE123', '--pretty'],
+        { from: 'user' },
+      )
+
+      expect(oneClickSpy).toHaveBeenCalledWith('ENCODED_UID', 'NONCE123')
+      expect(setAccountSpy).toHaveBeenCalled()
+      const output = JSON.parse(consoleLogSpy.mock.calls[0]![0] as string)
+      expect(output.authenticated).toBe(true)
+      expect(output.username).toBe('alice')
+
+      for (const spy of [oneClickSpy, setSessionPathSpy, ensurePathsSpy, setAccountSpy]) spy.mockRestore()
+    })
+
+    it('parses uid/token from a pasted --link', async () => {
+      const oneClickSpy = spyOn(InstagramClient.prototype, 'oneClickLogin').mockResolvedValue({ userId: '7' })
+      const setSessionPathSpy = spyOn(InstagramClient.prototype, 'setSessionPath').mockImplementation(() => {})
+      const ensurePathsSpy = spyOn(InstagramCredentialManager.prototype, 'ensureAccountPaths').mockResolvedValue({
+        account_dir: '/tmp/x',
+        session_path: '/tmp/x/session.json',
+      })
+      const setAccountSpy = spyOn(InstagramCredentialManager.prototype, 'setAccount').mockResolvedValue(undefined)
+
+      await authCommand.parseAsync(
+        [
+          'login-email',
+          '--username',
+          'bob',
+          '--link',
+          'https://www.instagram.com/_n/web_emaillogin?uid=U1&token=T1&auto_send=0',
+        ],
+        { from: 'user' },
+      )
+
+      expect(oneClickSpy).toHaveBeenCalledWith('U1', 'T1')
+
+      for (const spy of [oneClickSpy, setSessionPathSpy, ensurePathsSpy, setAccountSpy]) spy.mockRestore()
+    })
+
+    it('errors on an invalid --link instead of sending a new email', async () => {
+      const oneClickSpy = spyOn(InstagramClient.prototype, 'oneClickLogin').mockResolvedValue({ userId: '1' })
+      const sendEmailSpy = spyOn(InstagramClient.prototype, 'sendOneClickLoginEmail').mockResolvedValue({
+        sent: true,
+        contactPoint: '',
+      })
+
+      await expect(
+        authCommand.parseAsync(['login-email', '--username', 'alice', '--link', 'not-a-link', '--pretty'], {
+          from: 'user',
+        }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(sendEmailSpy).not.toHaveBeenCalled()
+      expect(oneClickSpy).not.toHaveBeenCalled()
+      const output = JSON.parse(consoleLogSpy.mock.calls[0]![0] as string)
+      expect(output.error).toContain('Invalid login link')
+
+      for (const spy of [oneClickSpy, sendEmailSpy]) spy.mockRestore()
+    })
+
+    it('errors when only --uid is provided without --token', async () => {
+      const sendEmailSpy = spyOn(InstagramClient.prototype, 'sendOneClickLoginEmail').mockResolvedValue({
+        sent: true,
+        contactPoint: '',
+      })
+
+      await expect(
+        authCommand.parseAsync(['login-email', '--username', 'alice', '--uid', 'U1', '--pretty'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(sendEmailSpy).not.toHaveBeenCalled()
+      const output = JSON.parse(consoleLogSpy.mock.calls[0]![0] as string)
+      expect(output.error).toContain('Invalid login link')
+
+      sendEmailSpy.mockRestore()
+    })
+
+    it('treats an explicit empty --link as redeem intent and fails closed', async () => {
+      const oneClickSpy = spyOn(InstagramClient.prototype, 'oneClickLogin').mockResolvedValue({ userId: '1' })
+      const sendEmailSpy = spyOn(InstagramClient.prototype, 'sendOneClickLoginEmail').mockResolvedValue({
+        sent: true,
+        contactPoint: '',
+      })
+
+      await expect(
+        authCommand.parseAsync(['login-email', '--username', 'alice', '--link', '', '--pretty'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(sendEmailSpy).not.toHaveBeenCalled()
+      expect(oneClickSpy).not.toHaveBeenCalled()
+      const output = JSON.parse(consoleLogSpy.mock.calls[0]![0] as string)
+      expect(output.error).toContain('Invalid login link')
+
+      for (const spy of [oneClickSpy, sendEmailSpy]) spy.mockRestore()
+    })
+
+    it('requires --username when redeeming non-interactively', async () => {
+      const oneClickSpy = spyOn(InstagramClient.prototype, 'oneClickLogin').mockResolvedValue({ userId: '1' })
+
+      await expect(
+        authCommand.parseAsync(['login-email', '--uid', 'U1', '--token', 'T1', '--pretty'], { from: 'user' }),
+      ).rejects.toThrow('process.exit called')
+
+      expect(oneClickSpy).not.toHaveBeenCalled()
+      const output = JSON.parse(consoleLogSpy.mock.calls[0]![0] as string)
+      expect(output.error).toContain('--username is required')
+
+      oneClickSpy.mockRestore()
+    })
+  })
+
+  describe('login email fallback', () => {
+    it('non-interactively sends the login email when password login offers it', async () => {
+      const authSpy = spyOn(InstagramClient.prototype, 'authenticate').mockResolvedValue({
+        userId: '',
+        oneClickEmailAvailable: true,
+      })
+      const sendEmailSpy = spyOn(InstagramClient.prototype, 'sendOneClickLoginEmail').mockResolvedValue({
+        sent: true,
+        contactPoint: 'j***@example.com',
+      })
+      const ensurePathsSpy = spyOn(InstagramCredentialManager.prototype, 'ensureAccountPaths').mockResolvedValue({
+        account_dir: '/tmp/x',
+        session_path: '/tmp/x/session.json',
+      })
+
+      await authCommand.parseAsync(['login', '--username', 'alice', '--password', 'wrong', '--pretty'], {
+        from: 'user',
+      })
+
+      expect(sendEmailSpy).toHaveBeenCalledWith('alice')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0]![0] as string)
+      expect(output.one_click_email_available).toBe(true)
+      expect(output.email_sent).toBe(true)
+      expect(output.contact_point).toBe('j***@example.com')
+
+      for (const spy of [authSpy, sendEmailSpy, ensurePathsSpy]) spy.mockRestore()
+    })
+  })
 })

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

@@ -1,4 +1,3 @@
-import { randomUUID } from 'node:crypto'
 import { mkdir, writeFile } from 'node:fs/promises'
 import { Writable } from 'node:stream'
 
@@ -10,7 +9,7 @@ import { isInteractive } from '@/shared/utils/interactive'
 import { formatOutput } from '@/shared/utils/output'
 import { info, warn, error as stderrError, debug } from '@/shared/utils/stderr'
 
-import { InstagramClient, generateAndroidDeviceId, generateDeviceString } from '../client'
+import { InstagramClient, generateDevice, parseOneClickLoginLink } from '../client'
 import { InstagramCredentialManager } from '../credential-manager'
 import { InstagramTokenExtractor } from '../token-extractor'
 import { createAccountId } from '../types'
@@ -26,6 +25,13 @@ async function promptText(message: string): Promise<string | undefined> {
   }
 }
 
+// Never trim passwords: they may contain leading/trailing spaces. Trimming corrupts them and
+// Instagram rejects the login as bad_password. Only strip the trailing CR some terminals add.
+export function sanitizePassword(raw: string): string | undefined {
+  const password = raw.replace(/\r$/, '')
+  return password.length > 0 ? password : undefined
+}
+
 async function promptHidden(message: string): Promise<string | undefined> {
   const { createInterface } = await import('node:readline/promises')
   const hiddenOutput = new (class extends Writable {
@@ -41,7 +47,7 @@ async function promptHidden(message: string): Promise<string | undefined> {
     process.stdout.write(`${message}: `)
     const answer = await rl.question('')
     process.stdout.write('\n')
-    return answer.trim() || undefined
+    return sanitizePassword(answer)
   } finally {
     hiddenOutput.muted = false
     rl.close()
@@ -187,12 +193,167 @@ async function loginAction(options: LoginOptions): Promise<void> {
       return
     }
 
+    if (result.oneClickEmailAvailable) {
+      if (interactive) {
+        await runEmailLogin(manager, username, options, client)
+      } else {
+        const { contactPoint } = await client.sendOneClickLoginEmail(username)
+        console.log(
+          formatOutput(
+            {
+              one_click_email_available: true,
+              email_sent: true,
+              contact_point: contactPoint,
+              message:
+                'Password login was rejected, but this account can log in by email. A login email was sent. Open the "Login as <username>" link and run "agent-instagram auth login-email --username <username> --link <url>" to finish.',
+            },
+            options.pretty,
+          ),
+        )
+      }
+      return
+    }
+
     await saveAccountAndPrint(manager, accountId, username, result.userId, options.pretty)
   } catch (error) {
     handleError(error as Error)
   }
 }
 
+interface LoginEmailOptions {
+  username?: string
+  link?: string
+  uid?: string
+  token?: string
+  pretty?: boolean
+  debug?: boolean
+}
+
+async function loginEmailAction(options: LoginEmailOptions): Promise<void> {
+  try {
+    const interactive = isInteractive()
+    const manager = new InstagramCredentialManager()
+
+    // Presence (not truthiness) signals redeem intent: an explicit empty --link "" must still
+    // fail closed here rather than falling through to the send-email branch and re-emailing.
+    const redeemAttempted = options.link !== undefined || options.uid !== undefined || options.token !== undefined
+    if (redeemAttempted) {
+      if (!options.username) {
+        console.log(
+          formatOutput({ error: '--username is required when redeeming a login email link.' }, options.pretty),
+        )
+        process.exit(1)
+      }
+      const redeem = resolveOneClickCredentials(options)
+      if (!redeem) {
+        console.log(
+          formatOutput(
+            { error: 'Invalid login link. Provide a valid --link <url>, or both --uid and --token.' },
+            options.pretty,
+          ),
+        )
+        process.exit(1)
+      }
+      await redeemLoginEmail(manager, redeem.uid, redeem.token, options.username, options)
+      return
+    }
+
+    let username = options.username
+    if (!username) {
+      if (!interactive) {
+        console.log(
+          formatOutput(
+            {
+              error:
+                'Username required. Use --username <username> to send the login email, then --link <url> (or --uid and --token) to complete.',
+            },
+            options.pretty,
+          ),
+        )
+        process.exit(1)
+      }
+      username = await promptText('Instagram username')
+      if (!username) {
+        stderrError('Username is required.')
+        process.exit(1)
+      }
+    }
+
+    const client = new InstagramClient(manager)
+    if (options.debug) client.setDebugLog((msg) => debug(`[debug] ${msg}`))
+
+    if (!interactive) {
+      const { contactPoint } = await client.sendOneClickLoginEmail(username)
+      console.log(
+        formatOutput(
+          {
+            email_sent: true,
+            contact_point: contactPoint,
+            message:
+              'Login email sent. Open the "Login as <username>" link and run "agent-instagram auth login-email --username <username> --link <url>" to finish.',
+          },
+          options.pretty,
+        ),
+      )
+      return
+    }
+
+    await runEmailLogin(manager, username, options, client)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function runEmailLogin(
+  manager: InstagramCredentialManager,
+  username: string,
+  options: LoginEmailOptions,
+  client: InstagramClient,
+): Promise<void> {
+  const { contactPoint } = await client.sendOneClickLoginEmail(username)
+
+  info(contactPoint ? `\n  Login email sent to: ${contactPoint}` : '\n  Login email sent.')
+  info('  Open the email, copy the "Login as ..." link, and paste it here.')
+  const link = await promptText('Login link')
+  if (!link) {
+    stderrError('Login link is required.')
+    process.exit(1)
+  }
+
+  const parsed = parseOneClickLoginLink(link)
+  if (!parsed) {
+    stderrError('Could not read uid and token from the pasted link.')
+    process.exit(1)
+  }
+
+  await redeemLoginEmail(manager, parsed.uid, parsed.token, username, options, client)
+}
+
+function resolveOneClickCredentials(options: LoginEmailOptions): { uid: string; token: string } | null {
+  if (options.link) return parseOneClickLoginLink(options.link)
+  if (options.uid && options.token) return { uid: options.uid, token: options.token }
+  return null
+}
+
+async function redeemLoginEmail(
+  manager: InstagramCredentialManager,
+  uid: string,
+  token: string,
+  username: string,
+  options: LoginEmailOptions,
+  existingClient?: InstagramClient,
+): Promise<void> {
+  const client = existingClient ?? new InstagramClient(manager)
+  if (!existingClient && options.debug) client.setDebugLog((msg) => debug(`[debug] ${msg}`))
+
+  const accountId = createAccountId(username)
+  const paths = await manager.ensureAccountPaths(accountId)
+  client.setSessionPath(paths.session_path)
+
+  const result = await client.oneClickLogin(uid, token)
+  await saveAccountAndPrint(manager, accountId, username, result.userId, options.pretty)
+}
+
 async function handleInteractiveChallenge(
   client: InstagramClient,
   manager: InstagramCredentialManager,
@@ -414,6 +575,12 @@ async function extractAction(options: { pretty?: boolean; debug?: boolean; brows
 
     const manager = new InstagramCredentialManager()
 
+    let device = await manager.loadDevice()
+    if (!device) {
+      device = generateDevice()
+      await manager.saveDevice(device)
+    }
+
     for (const extracted of results) {
       const session = {
         cookies: [
@@ -426,14 +593,7 @@ async function extractAction(options: { pretty?: boolean; debug?: boolean; brows
         ]
           .filter(Boolean)
           .join('; '),
-        device: {
-          phone_id: randomUUID(),
-          uuid: randomUUID(),
-          android_device_id: generateAndroidDeviceId(),
-          advertising_id: randomUUID(),
-          client_session_id: randomUUID(),
-          device_string: generateDeviceString(),
-        },
+        device,
         user_id: extracted.ds_user_id,
         mid: extracted.mid,
       }
@@ -530,6 +690,17 @@ export const authCommand = new Command('auth')
       .option('--debug', 'Show raw API responses')
       .action(loginAction),
   )
+  .addCommand(
+    new Command('login-email')
+      .description('Log in via a one-click login email link (no password needed)')
+      .option('--username <username>', 'Instagram username (sends the login email)')
+      .option('--link <url>', 'The "Login as <username>" URL from the email')
+      .option('--uid <uid>', 'uid from the email link (alternative to --link)')
+      .option('--token <token>', 'token from the email link (alternative to --link)')
+      .option('--pretty', 'Pretty print JSON output')
+      .option('--debug', 'Show raw API responses')
+      .action(loginEmailAction),
+  )
   .addCommand(
     new Command('extract')
       .description('Extract Instagram cookies from browser (Chrome, Edge, Arc, Brave)')

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

@@ -274,4 +274,34 @@ describe('InstagramCredentialManager', () => {
       expect(paths.session_path).toBe(join(testConfigDir, 'instagram', 'my-account', 'session.json'))
     })
   })
+
+  describe('device persistence', () => {
+    const device = {
+      phone_id: 'phone-1',
+      uuid: 'uuid-1',
+      android_device_id: 'android-abcdef0123456789',
+      advertising_id: 'adid-1',
+      client_session_id: 'csid-1',
+      device_string: '34/14; 480dpi; 1344x2992; Google/google; Pixel 8 Pro; husky; husky; en_US; 719358530',
+    }
+
+    it('returns null when no device is stored', async () => {
+      const manager = setup()
+      expect(await manager.loadDevice()).toBeNull()
+    })
+
+    it('persists and reloads the same device', async () => {
+      const manager = setup()
+      await manager.saveDevice(device)
+      expect(await manager.loadDevice()).toEqual(device)
+    })
+
+    it('shares one device across accounts (machine-level, not per-account)', async () => {
+      const manager = setup()
+      await manager.saveDevice(device)
+      await manager.setAccount(makeAccount({ account_id: 'a' }))
+      await manager.setAccount(makeAccount({ account_id: 'b' }))
+      expect(await manager.loadDevice()).toEqual(device)
+    })
+  })
 })

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

@@ -3,17 +3,39 @@ import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 
 import { getConfigDir } from '../../shared/utils/config-dir'
-import { createAccountId, type InstagramAccount, type InstagramAccountPaths, type InstagramConfig } from './types'
+import {
+  createAccountId,
+  type InstagramAccount,
+  type InstagramAccountPaths,
+  type InstagramConfig,
+  type InstagramDevice,
+} from './types'
 
 export class InstagramCredentialManager {
   private configDir: string
   private credentialsPath: string
   private instagramRootDir: string
+  private devicePath: string
 
   constructor(configDir?: string) {
     this.configDir = configDir ?? getConfigDir()
     this.credentialsPath = join(this.configDir, 'instagram-credentials.json')
     this.instagramRootDir = join(this.configDir, 'instagram')
+    this.devicePath = join(this.instagramRootDir, 'device.json')
+  }
+
+  async loadDevice(): Promise<InstagramDevice | null> {
+    if (!existsSync(this.devicePath)) return null
+    try {
+      return JSON.parse(await readFile(this.devicePath, 'utf-8')) as InstagramDevice
+    } catch {
+      return null
+    }
+  }
+
+  async saveDevice(device: InstagramDevice): Promise<void> {
+    await mkdir(this.instagramRootDir, { recursive: true })
+    await writeFile(this.devicePath, JSON.stringify(device, null, 2), { mode: 0o600 })
   }
 
   async loadConfig(): Promise<InstagramConfig> {

package/src/platforms/instagram/hybrid-listener.test.ts

@@ -0,0 +1,135 @@
+import { afterEach, describe, expect, it, mock } from 'bun:test'
+import { EventEmitter } from 'node:events'
+
+import { InstagramHybridListener } from '@/platforms/instagram/hybrid-listener'
+import type { InstagramRealtimeListener } from '@/platforms/instagram/realtime-listener'
+
+function makeRealtimeFailingClient() {
+  return {
+    getUserId: () => '123',
+    getSessionState: () => {
+      throw new Error('realtime bootstrap failed')
+    },
+    fetchIrisBootstrap: async () => {
+      throw new Error('realtime bootstrap failed')
+    },
+    listChats: mock(async () => []),
+  } as never
+}
+
+class FakeRealtimeListener {
+  private emitter = new EventEmitter()
+  stopped = false
+
+  on(event: string, handler: (...args: unknown[]) => void) {
+    this.emitter.on(event, handler)
+    return this
+  }
+  off() {
+    return this
+  }
+  once() {
+    return this
+  }
+  async start() {
+    this.emitter.emit('connected', { userId: '123' })
+  }
+  stop() {
+    this.stopped = true
+    this.emitter.emit('disconnected')
+  }
+  fail() {
+    this.emitter.emit('error', new Error('realtime connection lost'))
+  }
+}
+
+class TestableHybridListener extends InstagramHybridListener {
+  lastFake: FakeRealtimeListener | null = null
+  protected override createRealtimeListener(): InstagramRealtimeListener {
+    const fake = new FakeRealtimeListener()
+    this.lastFake = fake
+    return fake as unknown as InstagramRealtimeListener
+  }
+}
+
+describe('InstagramHybridListener', () => {
+  let listener: InstagramHybridListener
+
+  afterEach(() => {
+    listener?.stop()
+  })
+
+  it('falls back to polling and emits a single error when realtime startup fails', async () => {
+    const client = makeRealtimeFailingClient()
+    listener = new InstagramHybridListener(client, {
+      pollInterval: 60_000,
+      realtimeRetryBaseMs: 60_000,
+      realtimeRetryMaxMs: 60_000,
+    })
+
+    const errors: Error[] = []
+    listener.on('error', (err) => errors.push(err))
+
+    const connected = new Promise<{ userId: string; transport: string }>((resolve) => {
+      listener.on('connected', resolve)
+    })
+
+    await listener.start()
+    const info = await connected
+
+    // given a realtime failure, when startup fails, then it falls back to polling
+    expect(info.transport).toBe('polling')
+    // and the failure is reported exactly once (no recursive re-entry)
+    expect(errors).toHaveLength(1)
+  })
+
+  it('falls back to polling exactly once when a connected realtime listener fails', async () => {
+    const client = {
+      getUserId: () => '123',
+      listChats: mock(async () => []),
+    } as never
+    const testable = new TestableHybridListener(client, {
+      pollInterval: 60_000,
+      realtimeRetryBaseMs: 60_000,
+      realtimeRetryMaxMs: 60_000,
+    })
+    listener = testable
+
+    const errors: Error[] = []
+    const transports: string[] = []
+    testable.on('error', (err) => errors.push(err))
+    testable.on('connected', ({ transport }) => transports.push(transport))
+
+    await testable.start()
+    // given an established realtime connection
+    expect(transports).toContain('realtime')
+
+    const pollingConnected = new Promise<void>((resolve) => {
+      testable.on('connected', ({ transport }) => {
+        if (transport === 'polling') resolve()
+      })
+    })
+
+    // when the connected realtime listener fails
+    testable.lastFake!.fail()
+    await pollingConnected
+
+    // then the failure is reported once and it falls back to polling without recursion
+    expect(errors).toHaveLength(1)
+    expect(transports.filter((t) => t === 'polling')).toHaveLength(1)
+  })
+
+  it('uses polling directly when realtime is disabled', async () => {
+    const client = makeRealtimeFailingClient()
+    listener = new InstagramHybridListener(client, { pollInterval: 60_000, disableRealtime: true })
+
+    const connected = new Promise<{ transport: string }>((resolve) => {
+      listener.on('connected', resolve)
+    })
+
+    await listener.start()
+    const info = await connected
+
+    expect(info.transport).toBe('polling')
+  })
+})