agent-messenger 2.8.0 → 2.10.0

package/src/platforms/teams/commands/snapshot.ts

@@ -11,6 +11,7 @@ import type { TeamsChannel } from '../types'
 export async function snapshotAction(options: {
   channelsOnly?: boolean
   usersOnly?: boolean
+  full?: boolean
   limit?: number
   teamId?: string
   pretty?: boolean
@@ -33,8 +34,12 @@ export async function snapshotAction(options: {
       process.exit(1)
     }
 
-    const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })
-    const messageLimit = options.limit || 20
+    const client = await new TeamsClient().login({
+      token: cred.token,
+      tokenExpiresAt: cred.tokenExpiresAt,
+      accountType: cred.accountType,
+      region: cred.region,
+    })
 
     const snapshot: Record<string, unknown> = {}
 
@@ -45,47 +50,60 @@ export async function snapshotAction(options: {
       description: team.description,
     }
 
-    if (!options.usersOnly) {
-      const channels = await client.listChannels(teamId)
+    const isFull = options.full || options.channelsOnly || options.usersOnly
+    if (isFull) {
+      const messageLimit = options.limit || 20
 
-      snapshot.channels = channels.map((ch) => ({
-        id: ch.id,
-        name: ch.name,
-        type: ch.type,
-      }))
+      if (!options.usersOnly) {
+        const channels = await client.listChannels(teamId)
 
-      if (!options.channelsOnly) {
-        const channelMessages = await parallelMap(
-          channels,
-          async (channel: TeamsChannel) => {
-            const messages = await client.getMessages(teamId, channel.id, messageLimit)
-            return messages.map((msg) => ({
-              ...msg,
-              channel_name: channel.name,
-            }))
-          },
-          5,
-        )
-
-        snapshot.recent_messages = channelMessages.flat().map((msg) => ({
-          channel_id: msg.channel_id,
-          channel_name: msg.channel_name,
-          id: msg.id,
-          author: msg.author.displayName,
-          content: msg.content,
-          timestamp: msg.timestamp,
+        snapshot.channels = channels.map((ch) => ({
+          id: ch.id,
+          name: ch.name,
+          type: ch.type,
         }))
+
+        if (!options.channelsOnly) {
+          const channelMessages = await parallelMap(
+            channels,
+            async (channel: TeamsChannel) => {
+              const messages = await client.getMessages(teamId, channel.id, messageLimit)
+              return messages.map((msg) => ({
+                ...msg,
+                channel_name: channel.name,
+              }))
+            },
+            5,
+          )
+
+          snapshot.recent_messages = channelMessages.flat().map((msg) => ({
+            channel_id: msg.channel_id,
+            channel_name: msg.channel_name,
+            id: msg.id,
+            author: msg.author.displayName,
+            content: msg.content,
+            timestamp: msg.timestamp,
+          }))
+        }
       }
-    }
 
-    if (!options.channelsOnly) {
-      const users = await client.listUsers(teamId)
+      if (!options.channelsOnly) {
+        const users = await client.listUsers(teamId)
+
+        snapshot.members = users.map((u) => ({
+          id: u.id,
+          displayName: u.displayName,
+          email: u.email || null,
+        }))
+      }
+    } else {
+      if (!options.usersOnly) {
+        const channels = await client.listChannels(teamId)
+        snapshot.channels = channels.map((ch) => ({ id: ch.id, name: ch.name }))
+      }
 
-      snapshot.members = users.map((u) => ({
-        id: u.id,
-        displayName: u.displayName,
-        email: u.email || null,
-      }))
+      snapshot.hint =
+        "Use 'message list <channel>' for messages, 'channel info <channel>' for channel details, 'user list' for members."
     }
 
     console.log(formatOutput(snapshot, options.pretty))
@@ -95,16 +113,18 @@ export async function snapshotAction(options: {
 }
 
 export const snapshotCommand = new Command('snapshot')
-  .description('Get comprehensive team state for AI agents')
+  .description('Get team overview for AI agents (brief by default, use --full for comprehensive data)')
+  .option('--full', 'Include messages and members (verbose)')
   .option('--channels-only', 'Include only channels (exclude messages and members)')
   .option('--users-only', 'Include only members (exclude channels and messages)')
-  .option('--limit <n>', 'Number of recent messages per channel (default: 20)', '20')
+  .option('--limit <n>', 'Number of recent messages per channel with --full (default: 20)', '20')
   .option('--team-id <id>', 'Team ID (defaults to current team)')
   .option('--pretty', 'Pretty print JSON output')
   .action(async (options) => {
     await snapshotAction({
       channelsOnly: options.channelsOnly,
       usersOnly: options.usersOnly,
+      full: options.full,
       limit: parseInt(options.limit, 10),
       teamId: options.teamId,
       pretty: options.pretty,

package/src/platforms/teams/commands/team.test.ts

@@ -90,7 +90,7 @@ test('list: marks current team', async () => {
 
 test('info: returns team details', async () => {
   // given: teams client with team data
-  const client = await new TeamsClient().login({ token: 'test-token' })
+  const client = await new TeamsClient().login({ token: 'test-token', region: 'emea' })
   const team = await client.getTeam('team-1')
 
   // when: getting team info
@@ -104,7 +104,7 @@ test('info: returns team details', async () => {
 
 test('info: throws error for non-existent team', async () => {
   // given: teams client
-  const client = await new TeamsClient().login({ token: 'test-token' })
+  const client = await new TeamsClient().login({ token: 'test-token', region: 'emea' })
 
   // when: getting non-existent team
   // then: error is thrown

package/src/platforms/teams/commands/team.ts

@@ -34,7 +34,12 @@ export async function infoAction(teamId: string, options: { pretty?: boolean }):
       process.exit(1)
     }
 
-    const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })
+    const client = await new TeamsClient().login({
+      token: cred.token,
+      tokenExpiresAt: cred.tokenExpiresAt,
+      accountType: cred.accountType,
+      region: cred.region,
+    })
     const team = await client.getTeam(teamId)
 
     const output = {

package/src/platforms/teams/commands/user.ts

@@ -16,7 +16,12 @@ async function listAction(teamId: string, options: { pretty?: boolean }): Promis
       process.exit(1)
     }
 
-    const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })
+    const client = await new TeamsClient().login({
+      token: cred.token,
+      tokenExpiresAt: cred.tokenExpiresAt,
+      accountType: cred.accountType,
+      region: cred.region,
+    })
     const users = await client.listUsers(teamId)
 
     const output = users.map((user) => ({
@@ -42,7 +47,12 @@ async function infoAction(userId: string, options: { pretty?: boolean }): Promis
       process.exit(1)
     }
 
-    const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })
+    const client = await new TeamsClient().login({
+      token: cred.token,
+      tokenExpiresAt: cred.tokenExpiresAt,
+      accountType: cred.accountType,
+      region: cred.region,
+    })
     const user = await client.getUser(userId)
 
     const output = {
@@ -68,7 +78,12 @@ async function meAction(options: { pretty?: boolean }): Promise<void> {
       process.exit(1)
     }
 
-    const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })
+    const client = await new TeamsClient().login({
+      token: cred.token,
+      tokenExpiresAt: cred.tokenExpiresAt,
+      accountType: cred.accountType,
+      region: cred.region,
+    })
     const user = await client.testAuth()
 
     const output = {

package/src/platforms/teams/commands/whoami.ts

@@ -16,7 +16,12 @@ export async function whoamiAction(options: { pretty?: boolean }): Promise<void>
       return process.exit(1)
     }
 
-    const client = await new TeamsClient().login({ token: cred.token, tokenExpiresAt: cred.tokenExpiresAt })
+    const client = await new TeamsClient().login({
+      token: cred.token,
+      tokenExpiresAt: cred.tokenExpiresAt,
+      accountType: cred.accountType,
+      region: cred.region,
+    })
     const user = await client.testAuth()
 
     const output = {

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

@@ -88,6 +88,31 @@ describe('TeamsCredentialManager', () => {
     expect(team).toBeNull()
   })
 
+  test('getTokenWithExpiry includes region', async () => {
+    const manager = setup()
+    await manager.saveConfig({
+      current_account: 'work',
+      accounts: {
+        work: {
+          token: 'test-token',
+          token_expires_at: '2025-12-31T23:59:59Z',
+          region: 'emea',
+          account_type: 'work',
+          current_team: null,
+          teams: {},
+        },
+      },
+    })
+
+    const token = await manager.getTokenWithExpiry()
+    expect(token).toEqual({
+      token: 'test-token',
+      tokenExpiresAt: '2025-12-31T23:59:59Z',
+      accountType: 'work',
+      region: 'emea',
+    })
+  })
+
   test('getCurrentTeam returns null when current_team is set but team not in teams record', async () => {
     const manager = setup()
     await manager.setToken('test-token', 'work')

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

@@ -3,7 +3,7 @@ import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
-import type { TeamsAccount, TeamsAccountType, TeamsConfig, TeamsConfigLegacy } from './types'
+import type { TeamsAccount, TeamsAccountType, TeamsConfig, TeamsConfigLegacy, TeamsRegion } from './types'
 
 export class TeamsCredentialManager {
   static accountOverride?: TeamsAccountType
@@ -78,12 +78,22 @@ export class TeamsCredentialManager {
     return this.resolveCurrentAccount(config)?.token ?? null
   }
 
-  async getTokenWithExpiry(): Promise<{ token: string; tokenExpiresAt?: string } | null> {
+  async getTokenWithExpiry(): Promise<{
+    token: string
+    tokenExpiresAt?: string
+    accountType?: TeamsAccountType
+    region?: TeamsRegion
+  } | null> {
     const config = await this.loadConfig()
     if (!config) return null
     const account = this.resolveCurrentAccount(config)
     if (!account?.token) return null
-    return { token: account.token, tokenExpiresAt: account.token_expires_at }
+    return {
+      token: account.token,
+      tokenExpiresAt: account.token_expires_at,
+      accountType: account.account_type,
+      region: account.region,
+    }
   }
 
   async setToken(token: string, accountType: TeamsAccountType, expiresAt?: string): Promise<void> {

package/src/platforms/teams/ensure-auth.test.ts

@@ -10,6 +10,7 @@ let extractSpy: ReturnType<typeof spyOn>
 let testAuthSpy: ReturnType<typeof spyOn>
 let listTeamsSpy: ReturnType<typeof spyOn>
 let saveConfigSpy: ReturnType<typeof spyOn>
+let getRegionSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
   loadConfigSpy = spyOn(TeamsCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
@@ -28,6 +29,8 @@ beforeEach(() => {
     { id: 'team-2', name: 'Team Two' },
   ])
 
+  getRegionSpy = spyOn(TeamsClient.prototype, 'getRegion').mockReturnValue('emea')
+
   saveConfigSpy = spyOn(TeamsCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
 })
 
@@ -37,6 +40,7 @@ afterEach(() => {
   testAuthSpy?.mockRestore()
   listTeamsSpy?.mockRestore()
   saveConfigSpy?.mockRestore()
+  getRegionSpy?.mockRestore()
 })
 
 describe('ensureTeamsAuth', () => {
@@ -78,6 +82,7 @@ describe('ensureTeamsAuth', () => {
         accounts: expect.objectContaining({
           work: expect.objectContaining({
             token: 'test-teams-token',
+            region: 'emea',
             current_team: 'team-1',
             teams: {
               'team-1': { team_id: 'team-1', team_name: 'Team One' },
@@ -215,7 +220,7 @@ describe('ensureTeamsAuth', () => {
         current_account: 'work',
         accounts: expect.objectContaining({
           work: expect.objectContaining({ token: 'work-token', current_team: 'team-w' }),
-          personal: expect.objectContaining({ token: 'personal-token', current_team: 'team-p' }),
+          personal: expect.objectContaining({ token: 'personal-token', region: 'emea', current_team: 'team-p' }),
         }),
       }),
     )

package/src/platforms/teams/ensure-auth.ts

@@ -23,11 +23,15 @@ export async function ensureTeamsAuth(): Promise<void> {
 
     for (const { token, accountType } of extracted) {
       try {
-        const client = await new TeamsClient().login({ token })
+        const client = await new TeamsClient().login({
+          token,
+          accountType,
+          region: config?.accounts[accountType]?.region,
+        })
         await client.testAuth()
 
         const teams = await client.listTeams()
-        if (teams.length === 0) continue
+        if (accountType !== 'personal' && teams.length === 0) continue
 
         const teamMap: Record<string, { team_id: string; team_name: string }> = {}
         for (const team of teams) {
@@ -38,6 +42,7 @@ export async function ensureTeamsAuth(): Promise<void> {
         const account: TeamsAccount = {
           token,
           token_expires_at: new Date(Date.now() + 60 * 60 * 1000).toISOString(),
+          region: client.getRegion(),
           account_type: accountType,
           user_name: existing?.user_name,
           current_team: existing?.current_team ?? teams[0].id,

package/src/platforms/teams/token-extractor.ts

@@ -55,9 +55,11 @@ export class TeamsTokenExtractor {
   private platform: NodeJS.Platform
   private decryptor: ChromiumCookieDecryptor
   private cookieReader: ChromiumCookieReader
+  private debugLog: ((message: string) => void) | null
 
-  constructor(platform?: NodeJS.Platform, keyCache?: DerivedKeyCache) {
+  constructor(platform?: NodeJS.Platform, keyCache?: DerivedKeyCache, debugLog?: (message: string) => void) {
     this.platform = platform ?? process.platform
+    this.debugLog = debugLog ?? null
 
     const resolvedKeyCache = keyCache ?? new DerivedKeyCache()
     this.decryptor = new ChromiumCookieDecryptor({
@@ -69,6 +71,10 @@ export class TeamsTokenExtractor {
     this.cookieReader = new ChromiumCookieReader()
   }
 
+  private debug(message: string): void {
+    this.debugLog?.(message)
+  }
+
   getDesktopCookiesPaths(): TeamsCookiePath[] {
     switch (this.platform) {
       case 'darwin': {
@@ -197,17 +203,38 @@ export class TeamsTokenExtractor {
   private async extractFromCookiesDB(): Promise<ExtractedTeamsToken[]> {
     const results: ExtractedTeamsToken[] = []
     const seenAccountTypes = new Set<TeamsAccountType>()
+    const allPaths = this.getTeamsCookiesPaths()
+
+    this.debug(`Scanning ${allPaths.length} candidate cookie path(s)`)
+
+    for (const { path: dbPath, accountType } of allPaths) {
+      if (!dbPath) continue
+
+      if (!existsSync(dbPath)) {
+        this.debug(`  [skip] ${dbPath} (not found)`)
+        continue
+      }
+
+      if (seenAccountTypes.has(accountType)) {
+        this.debug(`  [skip] ${dbPath} (already have ${accountType} account)`)
+        continue
+      }
 
-    for (const { path: dbPath, accountType } of this.getTeamsCookiesPaths()) {
-      if (!dbPath || !existsSync(dbPath) || seenAccountTypes.has(accountType)) continue
+      this.debug(`  [try]  ${dbPath} (${accountType})`)
 
       const token = await this.copyAndExtract(dbPath)
       if (token && this.isValidSkypeToken(token)) {
+        this.debug(`  [ok]   Extracted valid token (${token.length} chars)`)
         results.push({ token, accountType })
         seenAccountTypes.add(accountType)
+      } else if (token) {
+        this.debug(`  [fail] Token too short (${token.length} chars, need >=50)`)
+      } else {
+        this.debug(`  [fail] No token extracted`)
       }
     }
 
+    this.debug(`Extraction complete: ${results.length} token(s) found`)
     return results
   }
 
@@ -216,11 +243,26 @@ export class TeamsTokenExtractor {
 
     try {
       tempPath = this.copyDatabaseToTemp(dbPath, dbPath)
-      const localStatePath =
-        this.platform === 'win32' ? (findLocalStatePath(dbPath) ?? this.getLocalStatePath()) : undefined
+
+      let localStatePath: string | undefined
+      if (this.platform === 'win32') {
+        localStatePath = findLocalStatePath(dbPath) ?? undefined
+        if (localStatePath) {
+          this.debug(`    Local State (from cookie path): ${localStatePath}`)
+        } else {
+          localStatePath = this.getLocalStatePath()
+          if (existsSync(localStatePath)) {
+            this.debug(`    Local State (fallback): ${localStatePath}`)
+          } else {
+            this.debug(`    Local State not found (tried fallback: ${localStatePath})`)
+            localStatePath = undefined
+          }
+        }
+      }
 
       return await this.extractFromSQLite(tempPath, localStatePath)
-    } catch {
+    } catch (error) {
+      this.debug(`    Copy/extract error: ${(error as Error).message}`)
       return null
     } finally {
       this.cleanupTempFile(tempPath)
@@ -231,27 +273,50 @@ export class TeamsTokenExtractor {
     try {
       for (const hostPattern of TEAMS_HOST_PATTERNS) {
         const sql = `
-          SELECT encrypted_value 
+          SELECT value, encrypted_value 
           FROM cookies 
           WHERE name = '${SKYPETOKEN_COOKIE_NAME}' 
           AND host_key LIKE '%${hostPattern}%'
           LIMIT 1
         `
 
-        type CookieRow = { encrypted_value?: Uint8Array | Buffer } | null
+        type CookieRow = { value?: string; encrypted_value?: Uint8Array | Buffer } | null
 
         const row = await this.cookieReader.queryFirst<CookieRow>(dbPath, sql)
-        if (!row?.encrypted_value) continue
+        if (!row) continue
+
+        if (row.value && row.value.length >= 50) {
+          this.debug(`    Found plaintext cookie for ${hostPattern} (${row.value.length} chars)`)
+          return row.value
+        }
+
+        if (!row.encrypted_value || row.encrypted_value.length === 0) {
+          this.debug(`    No cookie data for ${hostPattern}`)
+          continue
+        }
+
+        const encBuf = Buffer.from(row.encrypted_value)
+        const isEncrypted = this.isEncryptedValue(encBuf)
+        this.debug(
+          `    Found cookie for ${hostPattern}: ${encBuf.length} bytes, encrypted=${isEncrypted}, prefix=${encBuf.subarray(0, 3).toString('utf8')}`,
+        )
 
-        const decryptedBuf = this.decryptor.decryptCookieRaw(Buffer.from(row.encrypted_value), localStatePath)
-        if (!decryptedBuf) continue
+        const decryptedBuf = this.decryptor.decryptCookieRaw(encBuf, localStatePath)
+        if (!decryptedBuf) {
+          this.debug(`    Decryption failed`)
+          continue
+        }
 
+        this.debug(`    Decrypted: ${decryptedBuf.length} bytes`)
         const token = this.postProcessDecrypted(decryptedBuf)
         if (this.isValidSkypeToken(token)) return token
+
+        this.debug(`    Post-process result not a valid token (${token.length} chars)`)
       }
 
       return null
-    } catch {
+    } catch (error) {
+      this.debug(`    SQLite query error: ${(error as Error).message}`)
       return null
     }
   }

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

@@ -203,6 +203,7 @@ test('TeamsConfigSchema validates config with multiple accounts', () => {
       work: {
         token: 'work_token',
         token_expires_at: '2024-01-01T00:00:00.000Z',
+        region: 'emea',
         account_type: 'work',
         user_name: 'Work User',
         current_team: '19:abc123@thread.tacv2',
@@ -224,6 +225,22 @@ test('TeamsConfigSchema validates config with multiple accounts', () => {
   expect(result.success).toBe(true)
 })
 
+test('TeamsConfigSchema rejects invalid region', () => {
+  const result = TeamsConfigSchema.safeParse({
+    current_account: 'work',
+    accounts: {
+      work: {
+        token: 'token_value',
+        region: 'invalid',
+        account_type: 'work',
+        current_team: null,
+        teams: {},
+      },
+    },
+  })
+  expect(result.success).toBe(false)
+})
+
 test('TeamsConfigSchema rejects missing required fields', () => {
   const result = TeamsConfigSchema.safeParse({
     current_account: null,

package/src/platforms/teams/types.ts

@@ -55,9 +55,12 @@ export interface TeamsCredentials {
 
 export type TeamsAccountType = 'work' | 'personal'
 
+export type TeamsRegion = 'amer' | 'emea' | 'apac'
+
 export interface TeamsAccount {
   token: string
   token_expires_at?: string
+  region?: TeamsRegion
   account_type: TeamsAccountType
   user_name?: string
   current_team: string | null
@@ -141,9 +144,12 @@ export const TeamsCredentialsSchema = z.object({
 
 export const TeamsAccountTypeSchema = z.enum(['work', 'personal'])
 
+export const TeamsRegionSchema = z.enum(['amer', 'emea', 'apac'])
+
 export const TeamsAccountSchema = z.object({
   token: z.string(),
   token_expires_at: z.string().optional(),
+  region: TeamsRegionSchema.optional(),
   account_type: TeamsAccountTypeSchema,
   user_name: z.string().optional(),
   current_team: z.string().nullable(),