agent-messenger 1.0.0 → 1.2.0

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

@@ -3,6 +3,7 @@ import { createDecipheriv, pbkdf2Sync } from 'node:crypto'
 import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
+import { DerivedKeyCache } from '../../shared/utils/derived-key-cache'
 
 export interface ExtractedDiscordToken {
   token: string
@@ -59,11 +60,19 @@ export class DiscordTokenExtractor {
   private platform: NodeJS.Platform
   private startupWait: number
   private killWait: number
-
-  constructor(platform?: NodeJS.Platform, startupWait?: number, killWait?: number) {
+  private keyCache: DerivedKeyCache
+  private cachedKey: Buffer | null = null
+
+  constructor(
+    platform?: NodeJS.Platform,
+    startupWait?: number,
+    killWait?: number,
+    keyCache?: DerivedKeyCache
+  ) {
     this.platform = platform ?? process.platform
     this.startupWait = startupWait ?? DISCORD_STARTUP_WAIT
     this.killWait = killWait ?? 1000
+    this.keyCache = keyCache ?? new DerivedKeyCache()
   }
 
   getDiscordDirs(): string[] {
@@ -123,6 +132,8 @@ export class DiscordTokenExtractor {
   }
 
   async extract(): Promise<ExtractedDiscordToken | null> {
+    await this.loadCachedKey()
+
     const levelDbToken = await this.extractFromLevelDB()
     if (levelDbToken) {
       return levelDbToken
@@ -138,6 +149,20 @@ export class DiscordTokenExtractor {
     return null
   }
 
+  private async loadCachedKey(): Promise<void> {
+    if (this.platform !== 'darwin') return
+
+    const cached = await this.keyCache.get('discord')
+    if (cached) {
+      this.cachedKey = cached
+    }
+  }
+
+  async clearKeyCache(): Promise<void> {
+    await this.keyCache.clear('discord')
+    this.cachedKey = null
+  }
+
   private async tryExtractViaCDP(): Promise<string | null> {
     const token = await this.extractViaCDP()
     if (token) {
@@ -288,6 +313,11 @@ export class DiscordTokenExtractor {
   }
 
   private decryptMacToken(encryptedData: Buffer, discordDir: string): string | null {
+    if (this.cachedKey) {
+      const decrypted = this.decryptAESCBC(encryptedData, this.cachedKey)
+      if (decrypted) return decrypted
+    }
+
     const variant = this.getVariantFromPath(discordDir)
     const keychainVariants = this.getKeychainVariants().filter((v) => {
       const lowerAccount = v.account.toLowerCase()
@@ -308,7 +338,11 @@ export class DiscordTokenExtractor {
 
         const key = pbkdf2Sync(password, 'saltysalt', 1003, 16, 'sha1')
         const decrypted = this.decryptAESCBC(encryptedData, key)
-        if (decrypted) return decrypted
+        if (decrypted) {
+          this.cachedKey = key
+          this.keyCache.set('discord', key).catch(() => {})
+          return decrypted
+        }
       } catch {}
     }
 

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

@@ -203,21 +203,21 @@ test('DiscordCredentialsSchema rejects missing token', () => {
 
 test('DiscordConfigSchema validates correct config', () => {
   const result = DiscordConfigSchema.safeParse({
-    current_guild: null,
+    current_server: null,
     token: 'token_value',
-    guilds: {},
+    servers: {},
   })
   expect(result.success).toBe(true)
 })
 
-test('DiscordConfigSchema validates config with guilds', () => {
+test('DiscordConfigSchema validates config with servers', () => {
   const result = DiscordConfigSchema.safeParse({
-    current_guild: '123456789012345678',
+    current_server: '123456789012345678',
     token: 'token_value',
-    guilds: {
+    servers: {
       '123456789012345678': {
-        guild_id: '123456789012345678',
-        guild_name: 'Test Guild',
+        server_id: '123456789012345678',
+        server_name: 'Test Server',
       },
     },
   })
@@ -226,7 +226,7 @@ test('DiscordConfigSchema validates config with guilds', () => {
 
 test('DiscordConfigSchema rejects missing required fields', () => {
   const result = DiscordConfigSchema.safeParse({
-    current_guild: null,
+    current_server: null,
     token: 'token_value',
   })
   expect(result.success).toBe(false)

package/src/platforms/discord/types.ts

@@ -18,6 +18,13 @@ export interface DiscordChannel {
   type: number
   topic?: string
   position?: number
+  parent_id?: string
+  thread_metadata?: {
+    archived?: boolean
+    auto_archive_duration?: number
+    archive_timestamp?: string
+    locked?: boolean
+  }
 }
 
 export interface DiscordMessage {
@@ -41,6 +48,14 @@ export interface DiscordUser {
   bot?: boolean
 }
 
+export interface DiscordDMChannel {
+  id: string
+  type: number // 1=DM, 3=Group DM
+  last_message_id?: string
+  recipients: DiscordUser[]
+  name?: string // Only for group DMs
+}
+
 export interface DiscordReaction {
   emoji: {
     id?: string
@@ -59,18 +74,92 @@ export interface DiscordFile {
   width?: number
 }
 
+export interface DiscordMention {
+  id: string
+  channel_id: string
+  author: { id: string; username: string }
+  content: string
+  timestamp: string
+  mention_everyone: boolean
+  mentions: DiscordUser[]
+  guild_id?: string
+}
+
+export interface DiscordUserNote {
+  user_id: string
+  note_user_id: string
+  note: string
+}
+
+export interface DiscordSearchResult {
+  id: string
+  channel_id: string
+  guild_id?: string
+  content: string
+  author: {
+    id: string
+    username: string
+  }
+  timestamp: string
+  hit: boolean
+}
+
+export interface DiscordSearchResponse {
+  total_results: number
+  messages: DiscordSearchResult[][]
+}
+
+export interface DiscordSearchOptions {
+  channelId?: string
+  authorId?: string
+  has?: 'file' | 'image' | 'video' | 'embed' | 'link' | 'sticker'
+  sortBy?: 'timestamp' | 'relevance'
+  sortOrder?: 'asc' | 'desc'
+  limit?: number
+  offset?: number
+}
+
+export interface DiscordRelationship {
+  id: string
+  type: number
+  user: DiscordUser
+  nickname?: string
+}
+
+export interface DiscordGuildMember {
+  user: DiscordUser
+  nick?: string
+  roles: string[]
+  joined_at: string
+  deaf: boolean
+  mute: boolean
+  flags: number
+}
+
+export interface DiscordUserProfile {
+  user: DiscordUser & { bio?: string }
+  connected_accounts: Array<{
+    type: string
+    id: string
+    name: string
+    verified: boolean
+  }>
+  premium_since?: string
+  mutual_guilds?: Array<{ id: string; nick?: string }>
+}
+
 export interface DiscordCredentials {
   token: string
 }
 
 export interface DiscordConfig {
-  current_guild: string | null
+  current_server: string | null
   token: string
-  guilds: Record<
+  servers: Record<
     string,
     {
-      guild_id: string
-      guild_name: string
+      server_id: string
+      server_name: string
     }
   >
 }
@@ -113,6 +202,14 @@ export const DiscordUserSchema = z.object({
   bot: z.boolean().optional(),
 })
 
+export const DiscordDMChannelSchema = z.object({
+  id: z.string(),
+  type: z.number(),
+  last_message_id: z.string().optional(),
+  recipients: z.array(DiscordUserSchema),
+  name: z.string().optional(),
+})
+
 export const DiscordReactionSchema = z.object({
   emoji: z.object({
     id: z.string().optional(),
@@ -131,18 +228,57 @@ export const DiscordFileSchema = z.object({
   width: z.number().optional(),
 })
 
+export const DiscordMentionSchema = z.object({
+  id: z.string(),
+  channel_id: z.string(),
+  author: z.object({
+    id: z.string(),
+    username: z.string(),
+  }),
+  content: z.string(),
+  timestamp: z.string(),
+  mention_everyone: z.boolean(),
+  mentions: z.array(DiscordUserSchema),
+  guild_id: z.string().optional(),
+})
+
+export const DiscordRelationshipSchema = z.object({
+  id: z.string(),
+  type: z.number(),
+  user: DiscordUserSchema,
+  nickname: z.string().optional(),
+})
+
+export const DiscordSearchResultSchema = z.object({
+  id: z.string(),
+  channel_id: z.string(),
+  guild_id: z.string().optional(),
+  content: z.string(),
+  author: z.object({
+    id: z.string(),
+    username: z.string(),
+  }),
+  timestamp: z.string(),
+  hit: z.boolean(),
+})
+
+export const DiscordSearchResponseSchema = z.object({
+  total_results: z.number(),
+  messages: z.array(z.array(DiscordSearchResultSchema)),
+})
+
 export const DiscordCredentialsSchema = z.object({
   token: z.string(),
 })
 
 export const DiscordConfigSchema = z.object({
-  current_guild: z.string().nullable(),
+  current_server: z.string().nullable(),
   token: z.string(),
-  guilds: z.record(
+  servers: z.record(
     z.string(),
     z.object({
-      guild_id: z.string(),
-      guild_name: z.string(),
+      server_id: z.string(),
+      server_name: z.string(),
     })
   ),
 })

package/{tests → src/platforms/slack}/cli.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, test } from 'bun:test'
 import { spawn } from 'bun'
-import pkg from '../package.json'
-import { handleError } from '../src/shared/utils/error-handler'
-import { formatOutput } from '../src/shared/utils/output'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import pkg from '../../../package.json'
 
 describe('CLI Framework', () => {
   describe('formatOutput utility', () => {

package/src/platforms/slack/cli.ts

@@ -3,12 +3,17 @@
 import { Command } from 'commander'
 import pkg from '../../../package.json'
 import {
+  activityCommand,
   authCommand,
   channelCommand,
+  draftsCommand,
   fileCommand,
   messageCommand,
   reactionCommand,
+  savedCommand,
+  sectionsCommand,
   snapshotCommand,
+  unreadCommand,
   userCommand,
   workspaceCommand,
 } from './commands/index'
@@ -30,6 +35,11 @@ program.addCommand(userCommand)
 program.addCommand(reactionCommand)
 program.addCommand(fileCommand)
 program.addCommand(snapshotCommand)
+program.addCommand(activityCommand)
+program.addCommand(draftsCommand)
+program.addCommand(savedCommand)
+program.addCommand(sectionsCommand)
+program.addCommand(unreadCommand)
 
 program.parse(process.argv)
 

package/{tests/slack-client.test.ts → src/platforms/slack/client.test.ts}

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from 'bun:test'
 import type { WebClient } from '@slack/web-api'
-import { SlackClient, SlackError } from '../src/platforms/slack/client'
+import { SlackClient, SlackError } from '@/platforms/slack/client'
 
 const mockWebClient: any = {
   conversations: {

package/src/platforms/slack/client.ts

@@ -1,5 +1,17 @@
 import { WebClient } from '@slack/web-api'
-import type { SlackChannel, SlackFile, SlackMessage, SlackSearchResult, SlackUser } from './types'
+import type {
+  SlackActivityItem,
+  SlackChannel,
+  SlackChannelSection,
+  SlackDraft,
+  SlackFile,
+  SlackMessage,
+  SlackSavedItem,
+  SlackSearchResult,
+  SlackThreadView,
+  SlackUnreadCounts,
+  SlackUser,
+} from './types'
 
 export class SlackError extends Error {
   code: string
@@ -463,4 +475,163 @@ export class SlackClient {
       }
     })
   }
+
+  async getUnreadCounts(): Promise<SlackUnreadCounts> {
+    return this.withRetry(async () => {
+      const response = await (this.client as any).client.counts()
+      this.checkResponse(response)
+
+      const channels = (response.channels || []).map((ch: any) => ({
+        id: ch.id || '',
+        name: ch.name || '',
+        unread_count: ch.unread_count || 0,
+        mention_count: ch.mention_count || 0,
+      }))
+
+      return {
+        channels,
+        total_unread: channels.reduce((sum: number, ch: any) => sum + ch.unread_count, 0),
+        total_mentions: channels.reduce((sum: number, ch: any) => sum + ch.mention_count, 0),
+      }
+    })
+  }
+
+  async getThreadView(channelId: string, ts: string): Promise<SlackThreadView> {
+    return this.withRetry(async () => {
+      const response = await (this.client as any).subscriptions.thread.getView({
+        channel: channelId,
+        thread_ts: ts,
+      })
+      this.checkResponse(response)
+
+      const view = response.view as any
+      return {
+        channel_id: view.channel_id || channelId,
+        thread_ts: view.thread_ts || ts,
+        unread_count: view.unread_count || 0,
+        last_read: view.last_read || '',
+        subscribed: view.subscribed || false,
+      }
+    })
+  }
+
+  async markRead(channelId: string, ts: string): Promise<void> {
+    return this.withRetry(async () => {
+      const response = await this.client.conversations.mark({
+        channel: channelId,
+        ts,
+      })
+      this.checkResponse(response)
+    })
+  }
+
+  async getActivityFeed(options?: {
+    types?: string
+    mode?: string
+    limit?: number
+  }): Promise<SlackActivityItem[]> {
+    return this.withRetry(async () => {
+      const response = await (this.client as any).activity.feed({
+        types: options?.types,
+        mode: options?.mode || 'chrono_reads_and_unreads',
+        limit: options?.limit || 20,
+      })
+      this.checkResponse(response)
+
+      const items = (response.items || []).map((item: any) => ({
+        id: item.id || '',
+        type: item.type || '',
+        channel: item.channel || '',
+        ts: item.ts || '',
+        text: item.text || '',
+        user: item.user || '',
+        created: item.created || 0,
+      }))
+
+      return items
+    })
+  }
+
+  async getSavedItems(cursor?: string): Promise<{
+    items: SlackSavedItem[]
+    has_more: boolean
+    next_cursor?: string
+  }> {
+    return this.withRetry(async () => {
+      const response = await (this.client as any).apiCall('saved.list', {
+        cursor,
+        limit: 100,
+      })
+      this.checkResponse(response)
+
+      const items = (response.items || []).map((item: any) => ({
+        type: item.type || 'message',
+        message: {
+          ts: item.message?.ts || '',
+          text: item.message?.text || '',
+          user: item.message?.user,
+          username: item.message?.username,
+          type: item.message?.type || 'message',
+          thread_ts: item.message?.thread_ts,
+          reply_count: item.message?.reply_count,
+          replies: item.message?.replies,
+          edited: item.message?.edited
+            ? {
+                user: item.message.edited.user || '',
+                ts: item.message.edited.ts || '',
+              }
+            : undefined,
+        },
+        channel: {
+          id: item.channel?.id || '',
+          name: item.channel?.name || '',
+        },
+        date_created: item.date_created || 0,
+      }))
+
+      return {
+        items,
+        has_more: response.has_more || false,
+        next_cursor: response.response_metadata?.next_cursor,
+      }
+    })
+  }
+
+  async getChannelSections(): Promise<SlackChannelSection[]> {
+    return this.withRetry(async () => {
+      const response = await (this.client as any).apiCall('users.channelSections.list')
+      this.checkResponse(response)
+
+      const sections = (response as any).channel_sections || []
+      return sections.map((section: any) => ({
+        id: section.id!,
+        name: section.name || '',
+        channel_ids: section.channel_ids || [],
+        date_created: section.date_created || 0,
+        date_updated: section.date_updated || 0,
+      }))
+    })
+  }
+
+  async getDrafts(cursor?: string): Promise<{ drafts: SlackDraft[]; next_cursor?: string }> {
+    return this.withRetry(async () => {
+      const response = await this.client.apiCall('drafts.list', {
+        cursor,
+      })
+      this.checkResponse(response)
+
+      const drafts = ((response as any).drafts || []).map((draft: any) => ({
+        id: draft.id || '',
+        channel_id: draft.channel_id || '',
+        message: draft.message || null,
+        date_created: draft.date_created || 0,
+        date_updated: draft.date_updated || 0,
+      }))
+
+      return {
+        drafts,
+        next_cursor: (response as any).response_metadata?.next_cursor,
+      }
+    })
+  }
 }

package/src/platforms/slack/commands/activity.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, mock, test } from 'bun:test'
+import { Command } from 'commander'
+import { activityCommand } from '@/platforms/slack/commands/activity'
+
+describe('activity command', () => {
+  describe('list subcommand', () => {
+    test('returns activity items', async () => {
+      const mockActivityItems = [
+        {
+          id: 'act_1',
+          type: 'thread_reply',
+          channel: 'C123',
+          ts: '1234567890.123456',
+          text: 'New reply in thread',
+          user: 'U456',
+          created: 1234567890,
+        },
+        {
+          id: 'act_2',
+          type: 'message_reaction',
+          channel: 'C456',
+          ts: '1234567891.123456',
+          text: 'Someone reacted to your message',
+          user: 'U789',
+          created: 1234567891,
+        },
+      ]
+
+      const mockGetActivityFeed = mock(() => Promise.resolve(mockActivityItems))
+      const result = await mockGetActivityFeed()
+
+      expect(result).toHaveLength(2)
+      expect(result[0].type).toBe('thread_reply')
+      expect(result[1].type).toBe('message_reaction')
+    })
+
+    test('respects limit option', async () => {
+      const mockActivityItems = [
+        {
+          id: 'act_1',
+          type: 'thread_reply',
+          channel: 'C123',
+          ts: '1234567890.123456',
+          text: 'New reply',
+          user: 'U456',
+          created: 1234567890,
+        },
+      ]
+
+      const mockGetActivityFeed = mock((_options?: { limit?: number }) =>
+        Promise.resolve(mockActivityItems)
+      )
+      const result = await mockGetActivityFeed({ limit: 10 })
+
+      expect(mockGetActivityFeed).toHaveBeenCalledWith({ limit: 10 })
+      expect(result).toHaveLength(1)
+    })
+
+    test('respects unread-only mode', async () => {
+      const mockActivityItems = [
+        {
+          id: 'act_1',
+          type: 'at_user',
+          channel: 'C123',
+          ts: '1234567890.123456',
+          text: 'You were mentioned',
+          user: 'U456',
+          created: 1234567890,
+        },
+      ]
+
+      const mockGetActivityFeed = mock((_options?: { mode?: string }) =>
+        Promise.resolve(mockActivityItems)
+      )
+      const result = await mockGetActivityFeed({ mode: 'priority_unreads_v1' })
+
+      expect(mockGetActivityFeed).toHaveBeenCalledWith({ mode: 'priority_unreads_v1' })
+      expect(result).toHaveLength(1)
+    })
+
+    test('respects types filter', async () => {
+      const mockActivityItems = [
+        {
+          id: 'act_1',
+          type: 'thread_reply',
+          channel: 'C123',
+          ts: '1234567890.123456',
+          text: 'New reply',
+          user: 'U456',
+          created: 1234567890,
+        },
+      ]
+
+      const mockGetActivityFeed = mock((_options?: { types?: string }) =>
+        Promise.resolve(mockActivityItems)
+      )
+      const result = await mockGetActivityFeed({ types: 'thread_reply,at_user' })
+
+      expect(mockGetActivityFeed).toHaveBeenCalledWith({ types: 'thread_reply,at_user' })
+      expect(result).toHaveLength(1)
+    })
+
+    test('handles empty activity feed', async () => {
+      const mockGetActivityFeed = mock(() => Promise.resolve([]))
+      const result = await mockGetActivityFeed()
+
+      expect(result).toHaveLength(0)
+    })
+  })
+
+  describe('command structure', () => {
+    test('activity command exists', () => {
+      expect(activityCommand).toBeInstanceOf(Command)
+    })
+
+    test('activity command has correct name', () => {
+      expect(activityCommand.name()).toBe('activity')
+    })
+
+    test('activity command has description', () => {
+      expect(activityCommand.description()).toBe('Activity feed commands')
+    })
+
+    test('list subcommand exists', () => {
+      const listCmd = activityCommand.commands.find((cmd) => cmd.name() === 'list')
+      expect(listCmd).toBeDefined()
+    })
+
+    test('list subcommand has --unread option', () => {
+      const listCmd = activityCommand.commands.find((cmd) => cmd.name() === 'list')
+      const unreadOption = listCmd?.options.find((opt) => opt.long === '--unread')
+      expect(unreadOption).toBeDefined()
+    })
+
+    test('list subcommand has --limit option', () => {
+      const listCmd = activityCommand.commands.find((cmd) => cmd.name() === 'list')
+      const limitOption = listCmd?.options.find((opt) => opt.long === '--limit')
+      expect(limitOption).toBeDefined()
+    })
+
+    test('list subcommand has --types option', () => {
+      const listCmd = activityCommand.commands.find((cmd) => cmd.name() === 'list')
+      const typesOption = listCmd?.options.find((opt) => opt.long === '--types')
+      expect(typesOption).toBeDefined()
+    })
+  })
+})