agent-messenger 1.0.0 → 1.1.0

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

@@ -0,0 +1,164 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+
+export async function listAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+    const teams = config?.teams ? Object.values(config.teams) : []
+
+    const output = teams.map((team) => ({
+      id: team.team_id,
+      name: team.team_name,
+      current: team.team_id === config?.current_team,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function infoAction(teamId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config?.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new TeamsClient(config.token, config.token_expires_at)
+    const team = await client.getTeam(teamId)
+
+    const output = {
+      id: team.id,
+      name: team.name,
+      description: team.description,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function switchAction(teamId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config?.teams?.[teamId]) {
+      console.log(formatOutput({ error: `Team not found: ${teamId}` }, options.pretty))
+      process.exit(1)
+    }
+
+    const team = config.teams[teamId]
+    await credManager.setCurrentTeam(teamId, team.team_name)
+    console.log(formatOutput({ current: teamId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function currentAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config?.current_team) {
+      console.log(
+        formatOutput({ error: 'No current team set. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const team = config.teams[config.current_team]
+
+    if (!team) {
+      console.log(
+        formatOutput({ error: 'Current team not found in configuration.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const output = {
+      team_id: team.team_id,
+      team_name: team.team_name,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function removeAction(teamId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config) {
+      console.log(formatOutput({ error: 'No configuration found.' }, options.pretty))
+      process.exit(1)
+    }
+
+    if (!config.teams[teamId]) {
+      console.log(formatOutput({ error: `Team not found: ${teamId}` }, options.pretty))
+      process.exit(1)
+    }
+
+    delete config.teams[teamId]
+
+    if (config.current_team === teamId) {
+      config.current_team = null
+    }
+
+    await credManager.saveConfig(config)
+    console.log(formatOutput({ removed: teamId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const teamCommand = new Command('team')
+  .description('Team management commands')
+  .addCommand(
+    new Command('list')
+      .description('List all teams')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction)
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get team info')
+      .argument('<team-id>', 'Team ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(infoAction)
+  )
+  .addCommand(
+    new Command('switch')
+      .description('Switch to team')
+      .argument('<team-id>', 'Team ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(switchAction)
+  )
+  .addCommand(
+    new Command('current')
+      .description('Show current team')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(currentAction)
+  )
+  .addCommand(
+    new Command('remove')
+      .description('Remove team from config')
+      .argument('<team-id>', 'Team ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(removeAction)
+  )

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

@@ -0,0 +1,83 @@
+import { expect, mock, test } from 'bun:test'
+
+// Mock TeamsClient
+const mockClient = {
+  testAuth: mock(async () => ({
+    id: 'user123',
+    displayName: 'Test User',
+    email: 'test@example.com',
+    userPrincipalName: 'test@example.com',
+  })),
+  getUser: mock(async (userId: string) => ({
+    id: userId,
+    displayName: 'Test User',
+    email: 'test@example.com',
+    userPrincipalName: 'test@example.com',
+  })),
+  listUsers: mock(async (_teamId: string) => [
+    {
+      id: 'user1',
+      displayName: 'Alice',
+      email: 'alice@example.com',
+    },
+    {
+      id: 'user2',
+      displayName: 'Bob',
+      email: 'bob@example.com',
+    },
+  ]),
+}
+
+test('me returns current user info', async () => {
+  // given: authenticated user
+  const user = await mockClient.testAuth()
+
+  // when: getting current user
+  const result = {
+    id: user.id,
+    displayName: user.displayName,
+    email: user.email,
+    userPrincipalName: user.userPrincipalName,
+  }
+
+  // then: returns user object
+  expect(result.id).toBe('user123')
+  expect(result.displayName).toBe('Test User')
+  expect(result.email).toBe('test@example.com')
+})
+
+test('info returns user details by id', async () => {
+  // given: user id
+  const userId = 'user123'
+
+  // when: getting user info
+  const user = await mockClient.getUser(userId)
+  const result = {
+    id: user.id,
+    displayName: user.displayName,
+    email: user.email,
+    userPrincipalName: user.userPrincipalName,
+  }
+
+  // then: returns user object
+  expect(result.id).toBe('user123')
+  expect(result.displayName).toBe('Test User')
+})
+
+test('list returns team members', async () => {
+  // given: team id
+  const teamId = 'team123'
+
+  // when: listing users
+  const users = await mockClient.listUsers(teamId)
+  const result = users.map((u) => ({
+    id: u.id,
+    displayName: u.displayName,
+    email: u.email,
+  }))
+
+  // then: returns array of users
+  expect(result).toHaveLength(2)
+  expect(result[0].displayName).toBe('Alice')
+  expect(result[1].displayName).toBe('Bob')
+})

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

@@ -0,0 +1,112 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { TeamsClient } from '../client'
+import { TeamsCredentialManager } from '../credential-manager'
+
+async function listAction(teamId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config?.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new TeamsClient(config.token, config.token_expires_at)
+    const users = await client.listUsers(teamId)
+
+    const output = users.map((user) => ({
+      id: user.id,
+      displayName: user.displayName,
+      email: user.email,
+      userPrincipalName: user.userPrincipalName,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function infoAction(userId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config?.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new TeamsClient(config.token, config.token_expires_at)
+    const user = await client.getUser(userId)
+
+    const output = {
+      id: user.id,
+      displayName: user.displayName,
+      email: user.email,
+      userPrincipalName: user.userPrincipalName,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function meAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const config = await credManager.loadConfig()
+
+    if (!config?.token) {
+      console.log(
+        formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty)
+      )
+      process.exit(1)
+    }
+
+    const client = new TeamsClient(config.token, config.token_expires_at)
+    const user = await client.testAuth()
+
+    const output = {
+      id: user.id,
+      displayName: user.displayName,
+      email: user.email,
+      userPrincipalName: user.userPrincipalName,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const userCommand = new Command('user')
+  .description('User commands')
+  .addCommand(
+    new Command('list')
+      .description('List team members')
+      .argument('<team-id>', 'Team ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction)
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get user info')
+      .argument('<user-id>', 'User ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(infoAction)
+  )
+  .addCommand(
+    new Command('me')
+      .description('Show current authenticated user')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(meAction)
+  )

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

@@ -0,0 +1,178 @@
+import { afterAll, describe, expect, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { TeamsCredentialManager } from './credential-manager'
+
+const testDirs: string[] = []
+
+function setup(): TeamsCredentialManager {
+  const testConfigDir = join(
+    import.meta.dir,
+    `.test-teams-config-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  )
+  testDirs.push(testConfigDir)
+  return new TeamsCredentialManager(testConfigDir)
+}
+
+afterAll(() => {
+  for (const dir of testDirs) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('TeamsCredentialManager', () => {
+  test('loadConfig returns null when file does not exist', async () => {
+    const manager = setup()
+    const config = await manager.loadConfig()
+
+    expect(config).toBeNull()
+  })
+
+  test('saveConfig creates config file with correct permissions', async () => {
+    const testConfigDir = join(
+      import.meta.dir,
+      `.test-teams-config-${Date.now()}-${Math.random().toString(36).slice(2)}`
+    )
+    testDirs.push(testConfigDir)
+    const manager = new TeamsCredentialManager(testConfigDir)
+    const config = {
+      token: 'test-token',
+      current_team: 'team-123',
+      teams: {
+        'team-123': { team_id: 'team-123', team_name: 'Test Team' },
+      },
+    }
+
+    await manager.saveConfig(config)
+
+    const credentialsPath = join(testConfigDir, 'teams-credentials.json')
+    expect(existsSync(credentialsPath)).toBe(true)
+
+    const file = Bun.file(credentialsPath)
+    const content = await file.text()
+    const loaded = JSON.parse(content)
+    expect(loaded).toEqual(config)
+  })
+
+  test('getToken returns null when not authenticated', async () => {
+    const manager = setup()
+    const token = await manager.getToken()
+    expect(token).toBeNull()
+  })
+
+  test('setToken saves token to config', async () => {
+    const manager = setup()
+    await manager.setToken('test-token-123')
+
+    const token = await manager.getToken()
+    expect(token).toBe('test-token-123')
+  })
+
+  test('setToken saves token with expiry', async () => {
+    const manager = setup()
+    const expiresAt = '2025-12-31T23:59:59Z'
+    await manager.setToken('test-token-123', expiresAt)
+
+    const config = await manager.loadConfig()
+    expect(config?.token).toBe('test-token-123')
+    expect(config?.token_expires_at).toBe(expiresAt)
+  })
+
+  test('getCurrentTeam returns null when not set', async () => {
+    const manager = setup()
+    const team = await manager.getCurrentTeam()
+    expect(team).toBeNull()
+  })
+
+  test('getCurrentTeam returns null when current_team is set but team not in teams record', async () => {
+    const manager = setup()
+    await manager.setToken('test-token')
+    const config = await manager.loadConfig()
+    if (config) {
+      config.current_team = 'non-existent-team'
+      await manager.saveConfig(config)
+    }
+
+    const team = await manager.getCurrentTeam()
+    expect(team).toBeNull()
+  })
+
+  test('setCurrentTeam saves team info', async () => {
+    const manager = setup()
+    await manager.setToken('test-token')
+    await manager.setCurrentTeam('team-456', 'My Team')
+
+    const team = await manager.getCurrentTeam()
+    expect(team).toEqual({ team_id: 'team-456', team_name: 'My Team' })
+  })
+
+  test('setCurrentTeam updates existing team', async () => {
+    const manager = setup()
+    await manager.setToken('test-token')
+    await manager.setCurrentTeam('team-1', 'Team One')
+    await manager.setCurrentTeam('team-2', 'Team Two')
+
+    const team = await manager.getCurrentTeam()
+    expect(team).toEqual({ team_id: 'team-2', team_name: 'Team Two' })
+
+    const config = await manager.loadConfig()
+    expect(config?.teams['team-1']).toEqual({ team_id: 'team-1', team_name: 'Team One' })
+    expect(config?.teams['team-2']).toEqual({ team_id: 'team-2', team_name: 'Team Two' })
+  })
+
+  test('clearCredentials removes all credentials', async () => {
+    const manager = setup()
+    await manager.setToken('test-token', '2025-12-31T23:59:59Z')
+    await manager.setCurrentTeam('team-123', 'Test Team')
+
+    await manager.clearCredentials()
+
+    const config = await manager.loadConfig()
+    expect(config).toBeNull()
+  })
+
+  test('isTokenExpired returns true when no config exists', async () => {
+    const manager = setup()
+    const expired = await manager.isTokenExpired()
+    expect(expired).toBe(true)
+  })
+
+  test('isTokenExpired returns true when no token_expires_at is set', async () => {
+    const manager = setup()
+    await manager.setToken('test-token')
+
+    const expired = await manager.isTokenExpired()
+    expect(expired).toBe(true)
+  })
+
+  test('isTokenExpired returns true when token is expired', async () => {
+    const manager = setup()
+    const pastDate = new Date(Date.now() - 60000).toISOString()
+    await manager.setToken('test-token', pastDate)
+
+    const expired = await manager.isTokenExpired()
+    expect(expired).toBe(true)
+  })
+
+  test('isTokenExpired returns false when token is not expired', async () => {
+    const manager = setup()
+    const futureDate = new Date(Date.now() + 3600000).toISOString()
+    await manager.setToken('test-token', futureDate)
+
+    const expired = await manager.isTokenExpired()
+    expect(expired).toBe(false)
+  })
+
+  test('multiple operations preserve existing data', async () => {
+    const manager = setup()
+    await manager.setToken('token-1', '2025-12-31T23:59:59Z')
+    await manager.setCurrentTeam('team-1', 'Team One')
+
+    await manager.setToken('token-2')
+
+    const config = await manager.loadConfig()
+    expect(config?.token).toBe('token-2')
+    expect(config?.current_team).toBe('team-1')
+    expect(config?.teams['team-1']).toEqual({ team_id: 'team-1', team_name: 'Team One' })
+  })
+})

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

@@ -0,0 +1,92 @@
+import { existsSync } from 'node:fs'
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import type { TeamsConfig } from './types'
+
+export class TeamsCredentialManager {
+  private configDir: string
+  private credentialsPath: string
+
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? join(homedir(), '.config', 'agent-messenger')
+    this.credentialsPath = join(this.configDir, 'teams-credentials.json')
+  }
+
+  async loadConfig(): Promise<TeamsConfig | null> {
+    if (!existsSync(this.credentialsPath)) {
+      return null
+    }
+
+    try {
+      const content = await readFile(this.credentialsPath, 'utf-8')
+      return JSON.parse(content) as TeamsConfig
+    } catch {
+      return null
+    }
+  }
+
+  async saveConfig(config: TeamsConfig): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    await writeFile(this.credentialsPath, JSON.stringify(config, null, 2), { mode: 0o600 })
+  }
+
+  async getToken(): Promise<string | null> {
+    const config = await this.loadConfig()
+    return config?.token ?? null
+  }
+
+  async setToken(token: string, expiresAt?: string): Promise<void> {
+    let config = await this.loadConfig()
+    if (!config) {
+      config = {
+        token,
+        current_team: null,
+        teams: {},
+      }
+    }
+    config.token = token
+    if (expiresAt !== undefined) {
+      config.token_expires_at = expiresAt
+    }
+    await this.saveConfig(config)
+  }
+
+  async getCurrentTeam(): Promise<{ team_id: string; team_name: string } | null> {
+    const config = await this.loadConfig()
+    if (!config?.current_team) {
+      return null
+    }
+    return config.teams[config.current_team] ?? null
+  }
+
+  async setCurrentTeam(teamId: string, teamName: string): Promise<void> {
+    let config = await this.loadConfig()
+    if (!config) {
+      config = {
+        token: '',
+        current_team: null,
+        teams: {},
+      }
+    }
+    config.current_team = teamId
+    config.teams[teamId] = { team_id: teamId, team_name: teamName }
+    await this.saveConfig(config)
+  }
+
+  async clearCredentials(): Promise<void> {
+    if (existsSync(this.credentialsPath)) {
+      await rm(this.credentialsPath)
+    }
+  }
+
+  async isTokenExpired(): Promise<boolean> {
+    const config = await this.loadConfig()
+    if (!config?.token_expires_at) {
+      return true
+    }
+
+    const expiresAt = new Date(config.token_expires_at)
+    return expiresAt.getTime() <= Date.now()
+  }
+}

package/src/platforms/teams/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Public exports for Teams platform module
+ */
+
+// TODO: Implement following src/platforms/discord pattern