agent-messenger 1.0.0

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

@@ -0,0 +1,158 @@
+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 listAction(options: {
+  type?: string
+  includeArchived?: boolean
+  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)
+    let channels = await client.listChannels()
+
+    if (!options.includeArchived) {
+      channels = channels.filter((c) => !c.is_archived)
+    }
+
+    if (options.type === 'public') {
+      channels = channels.filter((c) => !c.is_private)
+    } else if (options.type === 'private') {
+      channels = channels.filter((c) => c.is_private)
+    } else if (options.type === 'dm') {
+      channels = []
+    }
+
+    const output = channels.map((ch) => ({
+      id: ch.id,
+      name: ch.name,
+      is_private: ch.is_private,
+      ...(options.includeArchived && { is_archived: ch.is_archived }),
+      created: ch.created,
+      topic: ch.topic?.value,
+      purpose: ch.purpose?.value,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function infoAction(channel: string, 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 client = new SlackClient(workspace.token, workspace.cookie)
+    const ch = await client.getChannel(channel)
+
+    const output = {
+      id: ch.id,
+      name: ch.name,
+      is_private: ch.is_private,
+      is_archived: ch.is_archived,
+      created: ch.created,
+      creator: ch.creator,
+      topic: ch.topic,
+      purpose: ch.purpose,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function historyAction(
+  channel: string,
+  options: { 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 messages = await client.getMessages(channel, options.limit || 20)
+
+    const output = messages.map((msg) => ({
+      ts: msg.ts,
+      text: msg.text,
+      user: msg.user,
+      username: msg.username,
+      type: msg.type,
+      thread_ts: msg.thread_ts,
+      reply_count: msg.reply_count,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const channelCommand = new Command('channel')
+  .description('Channel commands')
+  .addCommand(
+    new Command('list')
+      .description('List channels')
+      .option('--type <public|private|dm>', 'Filter by channel type')
+      .option('--include-archived', 'Include archived channels')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction)
+  )
+  .addCommand(
+    new Command('info')
+      .description('Get channel info')
+      .argument('<channel>', 'Channel ID or name')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(infoAction)
+  )
+  .addCommand(
+    new Command('history')
+      .description('Get channel message history (alias for message list)')
+      .argument('<channel>', 'Channel ID or name')
+      .option('--limit <n>', 'Number of messages to fetch', '20')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((channel, options) => {
+        historyAction(channel, {
+          limit: parseInt(options.limit, 10),
+          pretty: options.pretty,
+        })
+      })
+  )

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

@@ -0,0 +1,153 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+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 uploadAction(
+  channel: string,
+  path: string,
+  options: { filename?: string; 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 filePath = resolve(path)
+    const fileBuffer = readFileSync(filePath)
+    const filename = options.filename || filePath.split('/').pop() || 'file'
+
+    const file = await client.uploadFile([channel], fileBuffer, filename)
+
+    const output = {
+      id: file.id,
+      name: file.name,
+      title: file.title,
+      mimetype: file.mimetype,
+      size: file.size,
+      url_private: file.url_private,
+      created: file.created,
+      user: file.user,
+      channels: file.channels,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function listAction(options: { channel?: string; 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 files = await client.listFiles(options.channel)
+
+    const output = files.map((file) => ({
+      id: file.id,
+      name: file.name,
+      title: file.title,
+      mimetype: file.mimetype,
+      size: file.size,
+      url_private: file.url_private,
+      created: file.created,
+      user: file.user,
+      channels: file.channels,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function infoAction(fileId: string, 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 client = new SlackClient(workspace.token, workspace.cookie)
+    const files = await client.listFiles()
+    const fileData = files.find((f) => f.id === fileId)
+
+    if (!fileData) {
+      console.log(formatOutput({ error: `File not found: ${fileId}` }, options.pretty))
+      process.exit(1)
+    }
+
+    const output = {
+      id: fileData.id,
+      name: fileData.name,
+      title: fileData.title,
+      mimetype: fileData.mimetype,
+      size: fileData.size,
+      url_private: fileData.url_private,
+      created: fileData.created,
+      user: fileData.user,
+      channels: fileData.channels,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const fileCommand = new Command('file')
+  .description('file commands')
+  .addCommand(
+    new Command('upload')
+      .description('upload file to channel')
+      .argument('<channel>', 'channel ID or name')
+      .argument('<path>', 'file path')
+      .option('--filename <name>', 'override filename')
+      .action(uploadAction)
+  )
+  .addCommand(
+    new Command('list')
+      .description('list files in workspace')
+      .option('--channel <id>', 'filter by channel')
+      .action(listAction)
+  )
+  .addCommand(
+    new Command('info')
+      .description('show file details')
+      .argument('<file>', 'file ID')
+      .action(infoAction)
+  )

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

@@ -0,0 +1,8 @@
+export { authCommand } from './auth'
+export { channelCommand } from './channel'
+export { fileCommand } from './file'
+export { messageCommand } from './message'
+export { reactionCommand } from './reaction'
+export { snapshotCommand } from './snapshot'
+export { userCommand } from './user'
+export { workspaceCommand } from './workspace'

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

@@ -0,0 +1,369 @@
+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'
+import type { SlackMessage } from '../types'
+
+async function sendAction(
+  channel: string,
+  text: string,
+  options: { thread?: string; 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 message = await client.sendMessage(channel, text, options.thread)
+
+    const output = {
+      ts: message.ts,
+      text: message.text,
+      type: message.type,
+      user: message.user,
+      thread_ts: message.thread_ts,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function listAction(
+  channel: string,
+  options: { limit?: number; thread?: string; 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 limit = options.limit || 20
+    const messages = await client.getMessages(channel, limit)
+
+    const output = messages.map((msg: SlackMessage) => ({
+      ts: msg.ts,
+      text: msg.text,
+      type: msg.type,
+      user: msg.user,
+      username: msg.username,
+      thread_ts: msg.thread_ts,
+      reply_count: msg.reply_count,
+      edited: msg.edited,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function getAction(
+  channel: string,
+  ts: string,
+  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 client = new SlackClient(workspace.token, workspace.cookie)
+    const message = await client.getMessage(channel, ts)
+
+    if (!message) {
+      console.log(formatOutput({ error: `Message not found: ${ts}` }, options.pretty))
+      process.exit(1)
+    }
+
+    const output = {
+      ts: message.ts,
+      text: message.text,
+      type: message.type,
+      user: message.user,
+      username: message.username,
+      thread_ts: message.thread_ts,
+      reply_count: message.reply_count,
+      edited: message.edited,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function updateAction(
+  channel: string,
+  ts: string,
+  text: string,
+  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 client = new SlackClient(workspace.token, workspace.cookie)
+    const message = await client.updateMessage(channel, ts, text)
+
+    const output = {
+      ts: message.ts,
+      text: message.text,
+      type: message.type,
+      user: message.user,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function deleteAction(
+  channel: string,
+  ts: string,
+  options: { force?: boolean; 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)
+    }
+
+    if (!options.force) {
+      console.log(formatOutput({ warning: 'Use --force to confirm deletion', ts }, options.pretty))
+      process.exit(0)
+    }
+
+    const client = new SlackClient(workspace.token, workspace.cookie)
+    await client.deleteMessage(channel, ts)
+
+    console.log(formatOutput({ deleted: ts }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function searchAction(
+  query: string,
+  options: { sort?: string; sortDir?: string; 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 results = await client.searchMessages(query, {
+      sort: options.sort as 'score' | 'timestamp',
+      sortDir: options.sortDir as 'asc' | 'desc',
+      count: options.limit || 20,
+    })
+
+    const output = results.map((result) => ({
+      ts: result.ts,
+      text: result.text,
+      user: result.user,
+      username: result.username,
+      channel_id: result.channel.id,
+      channel_name: result.channel.name,
+      permalink: result.permalink,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function repliesAction(
+  channel: string,
+  threadTs: string,
+  options: { limit?: number; oldest?: string; latest?: string; cursor?: string; 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 result = await client.getThreadReplies(channel, threadTs, {
+      limit: options.limit,
+      oldest: options.oldest,
+      latest: options.latest,
+      cursor: options.cursor,
+    })
+
+    const output = result.messages.map((msg: SlackMessage) => ({
+      ts: msg.ts,
+      text: msg.text,
+      type: msg.type,
+      user: msg.user,
+      username: msg.username,
+      thread_ts: msg.thread_ts,
+      reply_count: msg.reply_count,
+      edited: msg.edited,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const messageCommand = new Command('message')
+  .description('Message commands')
+  .addCommand(
+    new Command('send')
+      .description('Send message to channel')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<text>', 'Message text')
+      .option('--thread <ts>', 'Thread timestamp for replies')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(sendAction)
+  )
+  .addCommand(
+    new Command('list')
+      .description('List messages from channel')
+      .argument('<channel>', 'Channel ID or name')
+      .option('--limit <n>', 'Number of messages to retrieve', '20')
+      .option('--thread <ts>', 'Filter by thread timestamp')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((channel: string, options: any) => {
+        listAction(channel, {
+          limit: parseInt(options.limit, 10),
+          thread: options.thread,
+          pretty: options.pretty,
+        })
+      })
+  )
+  .addCommand(
+    new Command('get')
+      .description('Get a single message by timestamp')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<ts>', 'Message timestamp')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(getAction)
+  )
+  .addCommand(
+    new Command('update')
+      .description('Update message text')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<ts>', 'Message timestamp')
+      .argument('<text>', 'New message text')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(updateAction)
+  )
+  .addCommand(
+    new Command('delete')
+      .description('Delete message')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<ts>', 'Message timestamp')
+      .option('--force', 'Skip confirmation')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(deleteAction)
+  )
+  .addCommand(
+    new Command('search')
+      .description('Search messages across workspace')
+      .argument('<query>', 'Search query')
+      .option('--sort <type>', 'Sort by: score, timestamp (default: timestamp)')
+      .option('--sort-dir <dir>', 'Sort direction: asc, desc (default: desc)')
+      .option('--limit <n>', 'Number of results', '20')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((query: string, options: any) => {
+        searchAction(query, {
+          sort: options.sort,
+          sortDir: options.sortDir,
+          limit: parseInt(options.limit, 10),
+          pretty: options.pretty,
+        })
+      })
+  )
+  .addCommand(
+    new Command('replies')
+      .description('Get thread replies')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<thread_ts>', 'Thread timestamp')
+      .option('--limit <n>', 'Number of replies to retrieve', '100')
+      .option('--oldest <ts>', 'Only messages after this timestamp')
+      .option('--latest <ts>', 'Only messages before this timestamp')
+      .option('--cursor <cursor>', 'Pagination cursor for next page')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((channel: string, threadTs: string, options: any) => {
+        repliesAction(channel, threadTs, {
+          limit: options.limit ? parseInt(options.limit, 10) : undefined,
+          oldest: options.oldest,
+          latest: options.latest,
+          cursor: options.cursor,
+          pretty: options.pretty,
+        })
+      })
+  )