agent-messenger 1.0.0

package/src/platforms/slack/commands/reaction.ts

@@ -0,0 +1,166 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { SlackClient } from '../client'
+import { CredentialManager } from '../credential-manager'
+
+async function addAction(
+  channel: string,
+  ts: string,
+  emoji: string,
+  options: { pretty?: boolean }
+): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const ws = await credManager.getWorkspace()
+
+    if (!ws) {
+      console.log(
+        formatOutput(
+          { error: 'No workspace configured. Run "auth extract" first.' },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const client = new SlackClient(ws.token, ws.cookie)
+    await client.addReaction(channel, ts, emoji)
+
+    console.log(
+      formatOutput(
+        {
+          success: true,
+          channel,
+          ts,
+          emoji,
+        },
+        options.pretty
+      )
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function removeAction(
+  channel: string,
+  ts: string,
+  emoji: string,
+  options: { pretty?: boolean }
+): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const ws = await credManager.getWorkspace()
+
+    if (!ws) {
+      console.log(
+        formatOutput(
+          { error: 'No workspace configured. Run "auth extract" first.' },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const client = new SlackClient(ws.token, ws.cookie)
+    await client.removeReaction(channel, ts, emoji)
+
+    console.log(
+      formatOutput(
+        {
+          success: true,
+          channel,
+          ts,
+          emoji,
+        },
+        options.pretty
+      )
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function listAction(
+  channel: string,
+  ts: string,
+  options: { pretty?: boolean }
+): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const ws = await credManager.getWorkspace()
+
+    if (!ws) {
+      console.log(
+        formatOutput(
+          { error: 'No workspace configured. Run "auth extract" first.' },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const client = new SlackClient(ws.token, ws.cookie)
+    const messages = await client.getMessages(channel, 1)
+    const message = messages.find((m) => m.ts === ts)
+
+    if (!message) {
+      console.log(
+        formatOutput(
+          {
+            error: 'Message not found',
+            channel,
+            ts,
+          },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const reactions = (message as any).reactions || []
+
+    console.log(
+      formatOutput(
+        {
+          channel,
+          ts,
+          reactions,
+        },
+        options.pretty
+      )
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const reactionCommand = new Command('reaction')
+  .description('Reaction commands')
+  .addCommand(
+    new Command('add')
+      .description('Add emoji reaction to message')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<ts>', 'Message timestamp')
+      .argument('<emoji>', 'Emoji name (without colons)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(addAction)
+  )
+  .addCommand(
+    new Command('remove')
+      .description('Remove emoji reaction from message')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<ts>', 'Message timestamp')
+      .argument('<emoji>', 'Emoji name (without colons)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(removeAction)
+  )
+  .addCommand(
+    new Command('list')
+      .description('List reactions on a message')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<ts>', 'Message timestamp')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction)
+  )

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

@@ -0,0 +1,114 @@
+import { Command } from 'commander'
+import { parallelMap } from '../../../shared/utils/concurrency'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { SlackClient } from '../client'
+import { CredentialManager } from '../credential-manager'
+import type { SlackChannel } from '../types'
+
+async function snapshotAction(options: {
+  channelsOnly?: boolean
+  usersOnly?: boolean
+  limit?: number
+  pretty?: boolean
+}): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const workspace = await credManager.getWorkspace()
+
+    if (!workspace) {
+      console.log(
+        formatOutput(
+          { error: 'No current workspace set. Run "auth extract" first.' },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const client = new SlackClient(workspace.token, workspace.cookie)
+
+    const auth = await client.testAuth()
+    const messageLimit = options.limit || 20
+
+    const snapshot: Record<string, any> = {
+      workspace: {
+        id: auth.team_id,
+        name: auth.team,
+      },
+    }
+
+    if (!options.usersOnly) {
+      const channels = await client.listChannels()
+
+      snapshot.channels = channels.map((ch) => ({
+        id: ch.id,
+        name: ch.name,
+        is_private: ch.is_private,
+        is_archived: ch.is_archived,
+        created: ch.created,
+        topic: ch.topic?.value,
+        purpose: ch.purpose?.value,
+      }))
+
+      if (!options.channelsOnly) {
+        const activeChannels = channels.filter((ch) => !ch.is_archived)
+
+        const channelMessages = await parallelMap(
+          activeChannels,
+          async (channel: SlackChannel) => {
+            const messages = await client.getMessages(channel.id, messageLimit)
+            return messages.map((msg) => ({
+              ...msg,
+              channel_id: channel.id,
+              channel_name: channel.name,
+            }))
+          },
+          5
+        )
+
+        snapshot.recent_messages = channelMessages.flat().map((msg) => ({
+          channel_id: msg.channel_id,
+          channel_name: msg.channel_name,
+          ts: msg.ts,
+          text: msg.text,
+          user: msg.user,
+          username: msg.username,
+          thread_ts: msg.thread_ts,
+        }))
+      }
+    }
+
+    if (!options.channelsOnly) {
+      const users = await client.listUsers()
+
+      snapshot.users = users.map((u) => ({
+        id: u.id,
+        name: u.name,
+        real_name: u.real_name,
+        is_admin: u.is_admin,
+        is_bot: u.is_bot,
+        profile: u.profile,
+      }))
+    }
+
+    console.log(formatOutput(snapshot, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const snapshotCommand = new Command()
+  .name('snapshot')
+  .description('Get comprehensive workspace state for AI agents')
+  .option('--channels-only', 'Include only channels (exclude messages and users)')
+  .option('--users-only', 'Include only users (exclude channels and messages)')
+  .option('--limit <n>', 'Number of recent messages per channel (default: 20)', '20')
+  .action(async (options) => {
+    await snapshotAction({
+      channelsOnly: options.channelsOnly,
+      usersOnly: options.usersOnly,
+      limit: parseInt(options.limit, 10),
+      pretty: options.pretty,
+    })
+  })

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

@@ -0,0 +1,110 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { SlackClient } from '../client'
+import { CredentialManager } from '../credential-manager'
+
+async function getClient(pretty?: boolean): Promise<SlackClient | null> {
+  const credManager = new CredentialManager()
+  const workspace = await credManager.getWorkspace()
+
+  if (!workspace) {
+    console.log(
+      formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, pretty)
+    )
+    return null
+  }
+
+  return new SlackClient(workspace.token, workspace.cookie)
+}
+
+export const userCommand = new Command('user')
+  .description('user commands')
+  .addCommand(
+    new Command('list')
+      .description('list workspace users')
+      .option('--include-bots', 'include bot users')
+      .option('--pretty', 'pretty-print JSON output')
+      .action(async (options) => {
+        try {
+          const client = await getClient(options.pretty)
+          if (!client) return process.exit(1)
+
+          const users = await client.listUsers()
+
+          const filtered = options.includeBots ? users : users.filter((u) => !u.is_bot)
+
+          const output = filtered.map((user) => ({
+            id: user.id,
+            name: user.name,
+            real_name: user.real_name,
+            is_admin: user.is_admin,
+            is_owner: user.is_owner,
+            is_bot: user.is_bot,
+            is_app_user: user.is_app_user,
+            profile: user.profile,
+          }))
+
+          console.log(formatOutput(output, options.pretty))
+        } catch (error) {
+          handleError(error as Error)
+        }
+      })
+  )
+  .addCommand(
+    new Command('info')
+      .description('show user details')
+      .argument('<user>', 'user ID or username')
+      .option('--pretty', 'pretty-print JSON output')
+      .action(async (userArg, options) => {
+        try {
+          const client = await getClient(options.pretty)
+          if (!client) return process.exit(1)
+
+          const user = await client.getUser(userArg)
+
+          const output = {
+            id: user.id,
+            name: user.name,
+            real_name: user.real_name,
+            is_admin: user.is_admin,
+            is_owner: user.is_owner,
+            is_bot: user.is_bot,
+            is_app_user: user.is_app_user,
+            profile: user.profile,
+          }
+
+          console.log(formatOutput(output, options.pretty))
+        } catch (error) {
+          handleError(error as Error)
+        }
+      })
+  )
+  .addCommand(
+    new Command('me')
+      .description('show current authenticated user')
+      .option('--pretty', 'pretty-print JSON output')
+      .action(async (options) => {
+        try {
+          const client = await getClient(options.pretty)
+          if (!client) return process.exit(1)
+          const authInfo = await client.testAuth()
+          const user = await client.getUser(authInfo.user_id)
+
+          const output = {
+            id: user.id,
+            name: user.name,
+            real_name: user.real_name,
+            is_admin: user.is_admin,
+            is_owner: user.is_owner,
+            is_bot: user.is_bot,
+            is_app_user: user.is_app_user,
+            profile: user.profile,
+          }
+
+          console.log(formatOutput(output, options.pretty))
+        } catch (error) {
+          handleError(error as Error)
+        }
+      })
+  )

package/src/platforms/slack/commands/workspace.ts

@@ -0,0 +1,111 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { CredentialManager } from '../credential-manager'
+
+async function listAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const config = await credManager.load()
+    const workspaces = Object.values(config.workspaces)
+
+    const output = workspaces.map((ws) => ({
+      id: ws.workspace_id,
+      name: ws.workspace_name,
+      current: ws.workspace_id === config.current_workspace,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function switchAction(id: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const config = await credManager.load()
+
+    if (!config.workspaces[id]) {
+      console.log(formatOutput({ error: `Workspace not found: ${id}` }, options.pretty))
+      process.exit(1)
+    }
+
+    await credManager.setCurrentWorkspace(id)
+    console.log(formatOutput({ current: id }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function currentAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const workspace = await credManager.getWorkspace()
+
+    if (!workspace) {
+      console.log(
+        formatOutput(
+          { error: 'No current workspace set. Run "auth extract" first.' },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const output = {
+      workspace_id: workspace.workspace_id,
+      workspace_name: workspace.workspace_name,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function removeAction(id: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const config = await credManager.load()
+
+    if (!config.workspaces[id]) {
+      console.log(formatOutput({ error: `Workspace not found: ${id}` }, options.pretty))
+      process.exit(1)
+    }
+
+    await credManager.removeWorkspace(id)
+    console.log(formatOutput({ removed: id }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const workspaceCommand = new Command('workspace')
+  .description('Workspace management commands')
+  .addCommand(
+    new Command('list')
+      .description('List all workspaces')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction)
+  )
+  .addCommand(
+    new Command('switch')
+      .description('Switch to workspace')
+      .argument('<id>', 'Workspace ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(switchAction)
+  )
+  .addCommand(
+    new Command('current')
+      .description('Show current workspace')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(currentAction)
+  )
+  .addCommand(
+    new Command('remove')
+      .description('Remove workspace')
+      .argument('<id>', 'Workspace ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(removeAction)
+  )

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

@@ -0,0 +1,74 @@
+import { existsSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import type { Config, WorkspaceCredentials } from './types'
+
+export class CredentialManager {
+  private configDir: string
+  private credentialsPath: string
+
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? join(homedir(), '.config', 'agent-messenger')
+    this.credentialsPath = join(this.configDir, 'slack-credentials.json')
+  }
+
+  async load(): Promise<Config> {
+    if (!existsSync(this.credentialsPath)) {
+      return {
+        current_workspace: null,
+        workspaces: {},
+      }
+    }
+
+    const file = Bun.file(this.credentialsPath)
+    const content = await file.text()
+    return JSON.parse(content) as Config
+  }
+
+  async save(config: Config): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+
+    const file = Bun.file(this.credentialsPath)
+    await Bun.write(file, JSON.stringify(config, null, 2))
+
+    await Bun.spawn(['chmod', '0600', this.credentialsPath]).exited
+  }
+
+  async getWorkspace(id?: string): Promise<WorkspaceCredentials | null> {
+    const config = await this.load()
+
+    if (id) {
+      return config.workspaces[id] ?? null
+    }
+
+    if (!config.current_workspace) {
+      return null
+    }
+
+    return config.workspaces[config.current_workspace] ?? null
+  }
+
+  async setWorkspace(creds: WorkspaceCredentials): Promise<void> {
+    const config = await this.load()
+    config.workspaces[creds.workspace_id] = creds
+    await this.save(config)
+  }
+
+  async removeWorkspace(id: string): Promise<void> {
+    const config = await this.load()
+    delete config.workspaces[id]
+
+    if (config.current_workspace === id) {
+      config.current_workspace = null
+    }
+
+    await this.save(config)
+  }
+
+  async setCurrentWorkspace(id: string): Promise<void> {
+    const config = await this.load()
+    config.current_workspace = id
+    await this.save(config)
+  }
+}

package/src/platforms/slack/index.ts

@@ -0,0 +1,2 @@
+export { SlackClient, SlackError } from './client'
+export { CredentialManager } from './credential-manager'