agent-messenger 1.0.0 → 1.2.0

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

@@ -1,10 +1,13 @@
-import { Database } from 'bun:sqlite'
 import { execSync } from 'node:child_process'
 import { createDecipheriv, pbkdf2Sync } from 'node:crypto'
-import { existsSync, readdirSync, readFileSync } from 'node:fs'
-import { homedir } from 'node:os'
+import { copyFileSync, existsSync, readdirSync, readFileSync, rmSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { homedir, tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { ClassicLevel } from 'classic-level'
+import { DerivedKeyCache } from '../../shared/utils/derived-key-cache'
+
+const require = createRequire(import.meta.url)
 
 export interface ExtractedWorkspace {
   workspace_id: string
@@ -22,8 +25,9 @@ interface TokenInfo {
 export class TokenExtractor {
   private platform: NodeJS.Platform
   private slackDir: string
+  private keyCache: DerivedKeyCache
 
-  constructor(platform?: NodeJS.Platform, slackDir?: string) {
+  constructor(platform?: NodeJS.Platform, slackDir?: string, keyCache?: DerivedKeyCache) {
     this.platform = platform ?? process.platform
 
     if (!['darwin', 'linux', 'win32'].includes(this.platform)) {
@@ -31,6 +35,7 @@ export class TokenExtractor {
     }
 
     this.slackDir = slackDir ?? this.getSlackDir()
+    this.keyCache = keyCache ?? new DerivedKeyCache()
   }
 
   getSlackDir(): string {
@@ -72,6 +77,8 @@ export class TokenExtractor {
       throw new Error(`Slack directory not found: ${this.slackDir}`)
     }
 
+    await this.getDerivedKeyAsync()
+
     const tokens = await this.extractTokensFromLevelDB()
     if (tokens.length === 0) {
       return []
@@ -79,6 +86,21 @@ export class TokenExtractor {
 
     const cookie = await this.extractCookieFromSQLite()
 
+    if (!cookie && this.usedCachedKey) {
+      await this.clearKeyCache()
+      this.cachedKey = this.getDerivedKeyFromKeychain()
+      if (this.cachedKey) {
+        await this.keyCache.set('slack', this.cachedKey)
+        const retryCookie = await this.extractCookieFromSQLite()
+        return tokens.map((t) => ({
+          workspace_id: t.teamId,
+          workspace_name: t.teamName,
+          token: t.token,
+          cookie: retryCookie,
+        }))
+      }
+    }
+
     return tokens.map((t) => ({
       workspace_id: t.teamId,
       workspace_name: t.teamName,
@@ -395,20 +417,40 @@ export class TokenExtractor {
   }
 
   private readCookieFromDB(dbPath: string): string {
+    // Copy the database to a temp file to avoid SQLite lock contention
+    // when Slack is running and has a write lock on the Cookies database
+    const tempDbPath = join(
+      tmpdir(),
+      `slack-cookies-${Date.now()}-${Math.random().toString(36).slice(2)}.db`
+    )
+
     try {
-      const db = new Database(dbPath, { readonly: true })
+      copyFileSync(dbPath, tempDbPath)
+    } catch {
+      return ''
+    }
 
-      const row = db
-        .query(
-          `SELECT value, encrypted_value 
+    try {
+      const sql = `SELECT value, encrypted_value 
            FROM cookies 
            WHERE name = 'd' AND host_key LIKE '%slack.com%'
            ORDER BY last_access_utc DESC
            LIMIT 1`
-        )
-        .get() as { value?: string; encrypted_value?: Uint8Array } | null
 
-      db.close()
+      type CookieRow = { value?: string; encrypted_value?: Uint8Array | Buffer } | null
+
+      let row: CookieRow
+      if (typeof globalThis.Bun !== 'undefined') {
+        const { Database } = require('bun:sqlite')
+        const db = new Database(tempDbPath, { readonly: true })
+        row = db.query(sql).get() as CookieRow
+        db.close()
+      } else {
+        const Database = require('better-sqlite3')
+        const db = new Database(tempDbPath, { readonly: true })
+        row = db.prepare(sql).get() as CookieRow
+        db.close()
+      }
 
       if (!row) {
         return ''
@@ -428,6 +470,10 @@ export class TokenExtractor {
       return ''
     } catch {
       return ''
+    } finally {
+      try {
+        rmSync(tempDbPath, { force: true })
+      } catch {}
     }
   }
 
@@ -468,7 +514,38 @@ export class TokenExtractor {
     }
   }
 
+  private cachedKey: Buffer | null = null
+  private usedCachedKey = false
+
+  private async getDerivedKeyAsync(): Promise<Buffer | null> {
+    if (this.platform !== 'darwin') {
+      return null
+    }
+
+    const cached = await this.keyCache.get('slack')
+    if (cached) {
+      this.cachedKey = cached
+      this.usedCachedKey = true
+      return cached
+    }
+
+    const key = this.getDerivedKeyFromKeychain()
+    if (key) {
+      this.cachedKey = key
+      await this.keyCache.set('slack', key)
+      this.usedCachedKey = false
+    }
+    return key
+  }
+
   private getDerivedKey(): Buffer | null {
+    if (this.cachedKey) {
+      return this.cachedKey
+    }
+    return this.getDerivedKeyFromKeychain()
+  }
+
+  private getDerivedKeyFromKeychain(): Buffer | null {
     if (this.platform !== 'darwin') {
       return null
     }
@@ -487,10 +564,14 @@ export class TokenExtractor {
         ).trim()
       }
 
-      // Chrome/Electron uses PBKDF2 with these parameters
       return pbkdf2Sync(password, 'saltysalt', 1003, 16, 'sha1')
     } catch {
       return null
     }
   }
+
+  async clearKeyCache(): Promise<void> {
+    await this.keyCache.clear('slack')
+    this.cachedKey = null
+  }
 }

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

@@ -7,7 +7,7 @@ import {
   SlackReactionSchema,
   SlackUserSchema,
   WorkspaceCredentialsSchema,
-} from '../src/platforms/slack/types'
+} from '@/platforms/slack/types'
 
 test('SlackChannelSchema validates correct data', () => {
   const validChannel = {

package/src/platforms/slack/types.ts

@@ -84,6 +84,64 @@ export interface SlackSearchResult {
   permalink: string
 }
 
+export interface SlackUnreadCounts {
+  channels: Array<{
+    id: string
+    name: string
+    unread_count: number
+    mention_count: number
+  }>
+  total_unread: number
+  total_mentions: number
+}
+
+export interface SlackThreadView {
+  channel_id: string
+  thread_ts: string
+  unread_count: number
+  last_read: string
+  subscribed: boolean
+}
+
+export interface SlackSavedItem {
+  type: string
+  message: SlackMessage
+  channel: {
+    id: string
+    name: string
+  }
+  date_created: number
+}
+
+export interface SlackActivityItem {
+  id: string
+  type: string
+  channel: string
+  ts: string
+  text: string
+  user: string
+  created: number
+}
+
+export interface SlackDraft {
+  id: string
+  channel_id: string
+  message: {
+    text?: string
+    blocks?: any[]
+  } | null
+  date_created: number
+  date_updated: number
+}
+
+export interface SlackChannelSection {
+  id: string
+  name: string
+  channel_ids: string[]
+  date_created: number
+  date_updated: number
+}
+
 export interface WorkspaceCredentials {
   workspace_id: string
   workspace_name: string

package/src/platforms/teams/cli.ts

@@ -0,0 +1,36 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import pkg from '../../../package.json'
+import {
+  authCommand,
+  channelCommand,
+  fileCommand,
+  messageCommand,
+  reactionCommand,
+  snapshotCommand,
+  teamCommand,
+  userCommand,
+} from './commands'
+
+const program = new Command()
+
+program
+  .name('agent-teams')
+  .description('CLI tool for Microsoft Teams communication')
+  .version(pkg.version)
+  .option('--pretty', 'Pretty-print JSON output')
+  .option('--team <id>', 'Use specific team')
+
+program.addCommand(authCommand)
+program.addCommand(teamCommand)
+program.addCommand(channelCommand)
+program.addCommand(fileCommand)
+program.addCommand(messageCommand)
+program.addCommand(reactionCommand)
+program.addCommand(snapshotCommand)
+program.addCommand(userCommand)
+
+program.parse(process.argv)
+
+export default program