agent-messenger 2.28.0 → 2.29.1

package/src/platforms/teams/trouter.ts

@@ -0,0 +1,323 @@
+import { gunzipSync } from 'node:zlib'
+
+import type { TeamsAccountType } from './types'
+
+// Trouter is Teams' internal real-time notification service. Protocol shape was
+// reverse-engineered from the Teams web client and cross-checked against the
+// open-source purple-teams and eisbaw/ost implementations. It speaks socket.io
+// v1 (colon-prefixed frames) over a WebSocket, NOT engine.io.
+
+const TROUTER_BOOTSTRAP_URL = 'https://go.trouter.teams.microsoft.com/v4/a'
+// Personal/TFL accounts register against edge.skype.com; work accounts use
+// teams.microsoft.com.
+const REGISTRAR_URL_PERSONAL = 'https://edge.skype.com/registrar/prod/v2/registrations'
+const REGISTRAR_URL_WORK = 'https://teams.microsoft.com/registrar/prod/V2/registrations'
+const CLIENTINFO_VERSION = '27/1.0.0.2024101502'
+const TC = JSON.stringify({ cv: '2024.04.01.1', ua: 'TeamsCDL', hr: '', v: CLIENTINFO_VERSION })
+const USER_AGENT =
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Electron/35.3.0'
+const REGISTRATION_TTL_SECONDS = 86400
+
+export interface TrouterConnectParams {
+  [key: string]: string
+}
+
+export interface TrouterInfo {
+  socketio: string
+  surl: string
+  connectparams: TrouterConnectParams
+  ccid?: string
+}
+
+export interface TrouterRequestFrame {
+  id: number
+  url?: string
+  headers?: Record<string, string>
+  body?: string
+}
+
+interface RegistrationSpec {
+  appId: string
+  templateKey: string
+  pathSuffix: string
+  productContext: string
+}
+
+const REGISTRATION_SPECS: RegistrationSpec[] = [
+  {
+    appId: 'NextGenCalling',
+    templateKey: 'DesktopNgc_2.5:SkypeNgc',
+    pathSuffix: 'NGCallManagerWin',
+    productContext: '',
+  },
+  { appId: 'SkypeSpacesWeb', templateKey: 'SkypeSpacesWeb_2.4', pathSuffix: 'SkypeSpacesWeb', productContext: '' },
+  { appId: 'TeamsCDLWebWorker', templateKey: 'TeamsCDLWebWorker_2.6', pathSuffix: '', productContext: 'TFL' },
+]
+
+export function buildTrouterQuery(info: TrouterInfo, endpointId: string): string {
+  const params = new URLSearchParams()
+  params.set('v', 'v4')
+  for (const [key, value] of Object.entries(info.connectparams)) params.set(key, value)
+  params.set('tc', TC)
+  params.set('timeout', '40')
+  params.set('auth', 'true')
+  params.set('epid', endpointId)
+  if (info.ccid) params.set('ccid', info.ccid)
+  params.set('con_num', `${Date.now()}_1`)
+  return params.toString()
+}
+
+export async function fetchTrouterInfo(skypeToken: string, endpointId: string): Promise<TrouterInfo> {
+  const response = await fetch(`${TROUTER_BOOTSTRAP_URL}?epid=${encodeURIComponent(endpointId)}`, {
+    method: 'POST',
+    headers: { 'x-skypetoken': skypeToken, 'Content-Length': '0', 'User-Agent': USER_AGENT },
+  })
+  if (!response.ok) {
+    throw new Error(`Trouter bootstrap failed: ${response.status} ${response.statusText}`)
+  }
+  return (await response.json()) as TrouterInfo
+}
+
+export async function fetchTrouterSessionId(
+  info: TrouterInfo,
+  skypeToken: string,
+  endpointId: string,
+): Promise<string> {
+  const url = `${info.socketio}socket.io/1/?${buildTrouterQuery(info, endpointId)}`
+  const response = await fetch(url, { headers: { 'X-Skypetoken': skypeToken, 'User-Agent': USER_AGENT } })
+  if (!response.ok) {
+    throw new Error(`Trouter handshake failed: ${response.status} ${response.statusText}`)
+  }
+  const body = await response.text()
+  return body.split(':')[0]
+}
+
+export function buildWebSocketUrl(info: TrouterInfo, sessionId: string, endpointId: string): string {
+  return `${info.socketio}socket.io/1/websocket/${sessionId}?${buildTrouterQuery(info, endpointId)}`
+}
+
+export function buildAuthenticateFrame(info: TrouterInfo, idToken: string): string {
+  const message = {
+    name: 'user.authenticate',
+    args: [
+      {
+        headers: {
+          'X-Ms-Test-User': 'False',
+          Authorization: `Bearer ${idToken}`,
+          'X-MS-Migration': 'True',
+        },
+        connectparams: info.connectparams,
+      },
+    ],
+  }
+  return `5:::${JSON.stringify(message)}`
+}
+
+export function buildActivityFrame(sequence: number): string {
+  return `5:${sequence}::{"name":"user.activity","args":[{"state":"active"}]}`
+}
+
+export function buildPingFrame(sequence: number): string {
+  return `5:${sequence}::{"name":"ping"}`
+}
+
+// Trouter delivers messages as socket.io "3:::" data frames, which require an
+// HTTP-style 200 acknowledgement or the server marks the endpoint unresponsive
+// and stops routing.
+export function buildRequestAck(requestId: number): string {
+  return `3:::${JSON.stringify({ id: requestId, status: 200, body: '' })}`
+}
+
+// Server "5:<id>+::" event frames must be acked with "6:<id>::" or trouter
+// eventually drops the connection.
+export function buildEventAck(frame: string): string | null {
+  const match = frame.match(/^5:(\d+)\+?::/)
+  return match ? `6:${match[1]}::` : null
+}
+
+export async function registerEndpoint(
+  info: TrouterInfo,
+  skypeToken: string,
+  idToken: string,
+  endpointId: string,
+  accountType: TeamsAccountType,
+  makeId: () => string,
+): Promise<void> {
+  const registrarUrl = accountType === 'personal' ? REGISTRAR_URL_PERSONAL : REGISTRAR_URL_WORK
+
+  for (const spec of REGISTRATION_SPECS) {
+    // The messaging worker must reuse the endpoint id; call apps get fresh ids.
+    const registrationId = spec.appId === 'TeamsCDLWebWorker' ? endpointId : makeId()
+    const payload = {
+      clientDescription: {
+        appId: spec.appId,
+        aesKey: '',
+        languageId: 'en-US',
+        platform: 'edge',
+        templateKey: spec.templateKey,
+        platformUIVersion: CLIENTINFO_VERSION,
+        productContext: accountType === 'personal' ? spec.productContext : '',
+      },
+      registrationId,
+      nodeId: '',
+      transports: { TROUTER: [{ context: '', path: `${info.surl}${spec.pathSuffix}`, ttl: REGISTRATION_TTL_SECONDS }] },
+    }
+
+    const response = await fetch(registrarUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Skypetoken': skypeToken,
+        Authorization: `Bearer ${idToken}`,
+        'User-Agent': USER_AGENT,
+      },
+      body: JSON.stringify(payload),
+    })
+    if (!response.ok) {
+      throw new Error(`Trouter registration for ${spec.appId} failed: ${response.status}`)
+    }
+  }
+}
+
+export function parseRequestFrame(frame: string): TrouterRequestFrame | null {
+  if (!frame.startsWith('3:::')) return null
+  try {
+    const parsed = JSON.parse(frame.slice(4)) as unknown
+    if (typeof parsed !== 'object' || parsed === null) return null
+    const { id } = parsed as { id?: unknown }
+    if (typeof id !== 'number' || !Number.isFinite(id)) return null
+    return parsed as TrouterRequestFrame
+  } catch {
+    return null
+  }
+}
+
+export function isMessageLossFrame(frame: string): boolean {
+  if (!frame.startsWith('5:')) return false
+  const jsonStart = frame.indexOf('{')
+  if (jsonStart === -1) return false
+  try {
+    const payload = JSON.parse(frame.slice(jsonStart)) as { name?: string }
+    return payload.name === 'trouter.message_loss'
+  } catch {
+    return false
+  }
+}
+
+// Trouter message bodies may be gzip+base64 encoded, and nest a further encoded
+// payload under `cp` (gzip+base64) or `gp` (base64).
+export function decodeMessageBody(headers: Record<string, string>, body: string): Record<string, unknown> {
+  let raw = body
+  if (headers['X-Microsoft-Skype-Content-Encoding'] === 'gzip') {
+    raw = gunzipSync(Buffer.from(body, 'base64')).toString('utf8')
+  }
+  const obj = JSON.parse(raw) as Record<string, unknown>
+  if (typeof obj.cp === 'string') {
+    return JSON.parse(gunzipSync(Buffer.from(obj.cp, 'base64')).toString('utf8')) as Record<string, unknown>
+  }
+  if (typeof obj.gp === 'string') {
+    return JSON.parse(Buffer.from(obj.gp, 'base64').toString('utf8')) as Record<string, unknown>
+  }
+  return obj
+}
+
+export function extractChatId(link: string | undefined): string | null {
+  if (!link) return null
+  const match = link.match(/conversations\/([^/]+)/)
+  return match ? decodeURIComponent(match[1]) : null
+}
+
+// `id` is Teams' positional mention index (the content span's `itemid`); `mri`
+// is the target's Skype MRI, present only via `properties.mentions` metadata.
+export interface TrouterMention {
+  id: string
+  mri?: string
+  displayName: string
+}
+
+// 1:1 chats resolve to a unique roster / one-to-one conversation id; anything on
+// a thread (group chat OR team channel) shares the @thread.* family. The thread
+// family alone cannot tell a group chat from a channel — that needs the
+// conversation's groupId, which the realtime resource does not carry.
+export function isThreadConversation(conversationId: string): boolean {
+  return conversationId.includes('@thread.tacv2') || conversationId.includes('@thread.v2')
+}
+
+function parseJsonRecord(value: unknown): Record<string, unknown> | undefined {
+  const source = typeof value === 'string' ? safeJsonParse(value) : value
+  if (typeof source !== 'object' || source === null || Array.isArray(source)) return undefined
+  return source as Record<string, unknown>
+}
+
+function parseJsonArray(value: unknown): unknown[] | undefined {
+  const source = typeof value === 'string' ? safeJsonParse(value) : value
+  return Array.isArray(source) ? source : undefined
+}
+
+function safeJsonParse(value: string): unknown {
+  try {
+    return JSON.parse(value)
+  } catch {
+    return undefined
+  }
+}
+
+// Mentions arrive two ways: the authoritative `properties.mentions` array (JSON
+// or JSON-string) carries real MRIs, while the message content only has
+// positional `<span itemtype=".../Mention" itemid="N">Name</span>` markup with
+// no MRI. Prefer the metadata; fall back to scraping the content spans so a
+// mention is still surfaced when properties are missing. Never throws — bad
+// data yields an empty list.
+export function parseMentions(properties: unknown, content: string): TrouterMention[] {
+  const fromProperties = parseMentionsFromProperties(properties)
+  if (fromProperties.length > 0) return fromProperties
+  return parseMentionsFromContent(content)
+}
+
+function parseMentionsFromProperties(properties: unknown): TrouterMention[] {
+  const record = parseJsonRecord(properties)
+  if (!record) return []
+  const rawMentions = parseJsonArray(record.mentions)
+  if (!rawMentions) return []
+
+  const mentions: TrouterMention[] = []
+  for (const entry of rawMentions) {
+    if (typeof entry !== 'object' || entry === null) continue
+    const item = entry as Record<string, unknown>
+    const id = item.itemid
+    if (typeof id !== 'string' && typeof id !== 'number') continue
+    mentions.push({
+      id: String(id),
+      mri: typeof item.mri === 'string' ? item.mri : undefined,
+      displayName: typeof item.displayName === 'string' ? item.displayName : '',
+    })
+  }
+  return mentions
+}
+
+const MENTION_SPAN_REGEX = /<span\b[^>]*itemtype=["'][^"']*Mention[^"']*["'][^>]*>(.*?)<\/span>/gi
+
+function parseMentionsFromContent(content: string): TrouterMention[] {
+  const mentions: TrouterMention[] = []
+  for (const match of content.matchAll(MENTION_SPAN_REGEX)) {
+    const attributes = match[0]
+    const itemId = attributes.match(/itemid=["']([^"']*)["']/i)?.[1]
+    if (itemId === undefined) continue
+    mentions.push({
+      id: itemId,
+      displayName: stripTags(match[1]),
+    })
+  }
+  return mentions
+}
+
+function stripTags(html: string): string {
+  return html
+    .replace(/<[^>]*>/g, '')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .trim()
+}

package/src/platforms/teams/types.test.ts

@@ -8,6 +8,7 @@ import {
   TeamsFileSchema,
   TeamsMessageSchema,
   TeamsReactionSchema,
+  TeamsSearchResultSchema,
   TeamsTeamSchema,
   TeamsUserSchema,
 } from './types'
@@ -87,6 +88,22 @@ it('TeamsMessageSchema rejects missing required fields', () => {
   expect(result.success).toBe(false)
 })
 
+it('TeamsSearchResultSchema validates search result shape', () => {
+  const result = TeamsSearchResultSchema.safeParse({
+    id: 'msg-123',
+    content: 'Deploy complete',
+    author: { id: 'user-123', displayName: 'Alice' },
+    channel_id: 'channel-123',
+    thread_id: 'thread-123',
+    team_name: 'Team One',
+    channel_name: 'General',
+    timestamp: '2024-01-01T00:00:00.000Z',
+    permalink: 'https://teams.microsoft.com/l/message/msg-123',
+  })
+
+  expect(result.success).toBe(true)
+})
+
 // TeamsUserSchema tests
 it('TeamsUserSchema validates correct user', () => {
   const result = TeamsUserSchema.safeParse({

package/src/platforms/teams/types.ts

@@ -26,6 +26,24 @@ export interface TeamsMessage {
   }
   content: string
   timestamp: string
+  root_message_id?: string
+  parent_message_id?: string
+  is_thread_reply?: boolean
+}
+
+export interface TeamsSearchResult {
+  id: string
+  content: string
+  author: {
+    id: string
+    displayName: string
+  }
+  channel_id: string
+  thread_id?: string
+  team_name?: string
+  channel_name?: string
+  timestamp: string
+  permalink?: string
 }
 
 export interface TeamsUser {
@@ -56,6 +74,8 @@ export interface TeamsFile {
   size: number
   url: string
   contentType?: string
+  sharepoint_url?: string
+  object_url?: string
 }
 
 export interface TeamsCredentials {
@@ -67,6 +87,8 @@ export type TeamsAccountType = 'work' | 'personal'
 
 export type TeamsRegion = 'amer' | 'emea' | 'apac'
 
+export type TeamsAuthMethod = 'device-code' | 'browser' | 'extracted' | 'manual'
+
 export interface TeamsAccount {
   token: string
   token_expires_at?: string
@@ -81,6 +103,10 @@ export interface TeamsAccount {
       team_name: string
     }
   >
+  auth_method?: TeamsAuthMethod
+  aad_refresh_token?: string
+  aad_client_id?: string
+  aad_tenant_id?: string
 }
 
 export interface TeamsConfig {
@@ -125,6 +151,24 @@ export const TeamsMessageSchema = z.object({
   }),
   content: z.string(),
   timestamp: z.string(),
+  root_message_id: z.string().optional(),
+  parent_message_id: z.string().optional(),
+  is_thread_reply: z.boolean().optional(),
+})
+
+export const TeamsSearchResultSchema = z.object({
+  id: z.string(),
+  content: z.string(),
+  author: z.object({
+    id: z.string(),
+    displayName: z.string(),
+  }),
+  channel_id: z.string(),
+  thread_id: z.string().optional(),
+  team_name: z.string().optional(),
+  channel_name: z.string().optional(),
+  timestamp: z.string(),
+  permalink: z.string().optional(),
 })
 
 export const TeamsUserSchema = z.object({
@@ -155,6 +199,8 @@ export const TeamsFileSchema = z.object({
   size: z.number(),
   url: z.string(),
   contentType: z.string().optional(),
+  sharepoint_url: z.string().optional(),
+  object_url: z.string().optional(),
 })
 
 export const TeamsCredentialsSchema = z.object({
@@ -166,6 +212,8 @@ export const TeamsAccountTypeSchema = z.enum(['work', 'personal'])
 
 export const TeamsRegionSchema = z.enum(['amer', 'emea', 'apac'])
 
+export const TeamsAuthMethodSchema = z.enum(['device-code', 'browser', 'extracted', 'manual'])
+
 export const TeamsAccountSchema = z.object({
   token: z.string(),
   token_expires_at: z.string().optional(),
@@ -180,6 +228,10 @@ export const TeamsAccountSchema = z.object({
       team_name: z.string(),
     }),
   ),
+  auth_method: TeamsAuthMethodSchema.optional(),
+  aad_refresh_token: z.string().optional(),
+  aad_client_id: z.string().optional(),
+  aad_tenant_id: z.string().optional(),
 })
 
 export const TeamsConfigSchema = z.object({
@@ -200,6 +252,41 @@ export const TeamsConfigLegacySchema = z.object({
   ),
 })
 
+export interface TeamsMention {
+  id: string
+  mri?: string
+  displayName: string
+}
+
+export interface TeamsRealtimeMessage {
+  id: string
+  chatId: string
+  conversationType: 'chat' | 'channel'
+  teamId?: string
+  channelId?: string
+  content: string
+  mentions: TeamsMention[]
+  author: {
+    id: string
+    displayName: string
+  }
+  messageType: string
+  timestamp: string
+}
+
+export interface TeamsTrouterGenericEvent {
+  resourceType: string
+  [key: string]: unknown
+}
+
+export interface TeamsListenerEventMap {
+  message: [message: TeamsRealtimeMessage]
+  teams_event: [event: TeamsTrouterGenericEvent]
+  connected: [info: { endpointId: string }]
+  disconnected: []
+  error: [error: Error]
+}
+
 export class TeamsError extends Error {
   code: string
 
@@ -209,3 +296,12 @@ export class TeamsError extends Error {
     this.code = code
   }
 }
+
+export class TeamsAuthCapabilityError extends Error {
+  constructor() {
+    super(
+      'Requires `agent-teams auth login` — cookie-based auth (`auth extract`) can only provide a Skype token, not the Microsoft token needed for search or SharePoint/OneDrive file downloads.',
+    )
+    this.name = 'TeamsAuthCapabilityError'
+  }
+}

package/src/tui/adapters/instagram-adapter.ts

@@ -107,8 +107,21 @@ export class InstagramAdapter implements PlatformAdapter {
       if (!code) throw new Error('Verification code is required')
       const challengeResult = await client.challengeSubmitCode(result.challengePath, code)
       userId = challengeResult.userId || userId
+    } else if (result.oneClickEmailAvailable) {
+      const { parseOneClickLoginLink } = await import('@/platforms/instagram/client')
+      io.print('Password login was rejected; this account can log in by email. Sending a login email...')
+      const { contactPoint } = await client.sendOneClickLoginEmail(username)
+      io.print(contactPoint ? `Login email sent to ${contactPoint}.` : 'Login email sent.')
+      const link = await io.prompt('Paste the "Login as ..." link from the email')
+      if (!link) throw new Error('Login link is required')
+      const parsed = parseOneClickLoginLink(link)
+      if (!parsed) throw new Error('Could not read uid and token from the pasted link')
+      const emailResult = await client.oneClickLogin(parsed.uid, parsed.token)
+      userId = emailResult.userId || userId
     }
 
+    if (!userId) throw new Error('Login did not complete')
+
     const now = new Date().toISOString()
     await this.credManager.setAccount({
       account_id: accountId,

package/src/tui/adapters/teams-adapter.ts

@@ -1,4 +1,5 @@
 import { TeamsClient } from '@/platforms/teams/client'
+import { TeamsListener } from '@/platforms/teams/listener'
 
 import type { AuthHint, AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage, Workspace } from './types'
 
@@ -6,6 +7,7 @@ export class TeamsAdapter implements PlatformAdapter {
   readonly name = 'Teams'
 
   private client: TeamsClient | null = null
+  private listener: TeamsListener | null = null
   private teamId: string | null = null
   private teamName: string | null = null
   private teams: Workspace[] = []
@@ -49,6 +51,27 @@ export class TeamsAdapter implements PlatformAdapter {
     await this.client!.sendMessage(this.teamId!, channelId, text)
   }
 
+  async startListening(onMessage: (msg: UnifiedMessage) => void): Promise<void> {
+    this.ensureClient()
+    const listener = new TeamsListener(this.client!)
+    listener.on('message', (message) => {
+      onMessage({
+        id: message.id,
+        channelId: message.chatId,
+        author: message.author.displayName,
+        content: message.content,
+        timestamp: message.timestamp,
+      })
+    })
+    await listener.start()
+    this.listener = listener
+  }
+
+  stopListening(): void {
+    this.listener?.stop()
+    this.listener = null
+  }
+
   async getWorkspaces(): Promise<Workspace[]> {
     return this.teams
   }

package/src/tui/app.ts

@@ -270,7 +270,7 @@ export async function createApp(): Promise<void> {
     left: 0,
     top: 1,
     width: 28,
-    height: '100%-4',
+    height: '100%-5',
     border: { type: 'line' },
     style: {
       border: { fg: '#444444' },
@@ -288,7 +288,7 @@ export async function createApp(): Promise<void> {
     left: 28,
     top: 1,
     right: 0,
-    height: '100%-4',
+    height: '100%-5',
     border: { type: 'line' },
     style: {
       border: { fg: '#444444' },
@@ -304,7 +304,7 @@ export async function createApp(): Promise<void> {
 
   const inputBox = blessed.textarea({
     parent: screen,
-    bottom: 0,
+    bottom: 1,
     left: 0,
     right: 0,
     height: 3,