agent-messenger 1.0.0

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

@@ -0,0 +1,245 @@
+import { expect, test } from 'bun:test'
+import {
+  DiscordChannelSchema,
+  DiscordConfigSchema,
+  DiscordCredentialsSchema,
+  DiscordError,
+  DiscordFileSchema,
+  DiscordGuildSchema,
+  DiscordMessageSchema,
+  DiscordReactionSchema,
+  DiscordUserSchema,
+} from './types'
+
+test('DiscordGuildSchema validates correct guild', () => {
+  const result = DiscordGuildSchema.safeParse({
+    id: '123456789012345678',
+    name: 'Test Guild',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordGuildSchema rejects missing id', () => {
+  const result = DiscordGuildSchema.safeParse({
+    name: 'Test Guild',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('DiscordGuildSchema rejects missing name', () => {
+  const result = DiscordGuildSchema.safeParse({
+    id: '123456789012345678',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('DiscordChannelSchema validates correct channel', () => {
+  const result = DiscordChannelSchema.safeParse({
+    id: '987654321098765432',
+    guild_id: '123456789012345678',
+    name: 'general',
+    type: 0,
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordChannelSchema validates channel with optional fields', () => {
+  const result = DiscordChannelSchema.safeParse({
+    id: '987654321098765432',
+    guild_id: '123456789012345678',
+    name: 'general',
+    type: 0,
+    topic: 'Channel topic',
+    position: 0,
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordChannelSchema rejects missing required fields', () => {
+  const result = DiscordChannelSchema.safeParse({
+    id: '987654321098765432',
+    name: 'general',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('DiscordMessageSchema validates correct message', () => {
+  const result = DiscordMessageSchema.safeParse({
+    id: '111222333444555666',
+    channel_id: '987654321098765432',
+    author: {
+      id: '222333444555666777',
+      username: 'testuser',
+    },
+    content: 'Hello world',
+    timestamp: '2024-01-01T00:00:00.000Z',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordMessageSchema validates message with optional fields', () => {
+  const result = DiscordMessageSchema.safeParse({
+    id: '111222333444555666',
+    channel_id: '987654321098765432',
+    author: {
+      id: '222333444555666777',
+      username: 'testuser',
+    },
+    content: 'Hello world',
+    timestamp: '2024-01-01T00:00:00.000Z',
+    edited_timestamp: '2024-01-01T00:01:00.000Z',
+    thread_id: '333444555666777888',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordMessageSchema rejects missing required fields', () => {
+  const result = DiscordMessageSchema.safeParse({
+    id: '111222333444555666',
+    channel_id: '987654321098765432',
+    content: 'Hello world',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('DiscordUserSchema validates correct user', () => {
+  const result = DiscordUserSchema.safeParse({
+    id: '222333444555666777',
+    username: 'testuser',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordUserSchema validates user with optional fields', () => {
+  const result = DiscordUserSchema.safeParse({
+    id: '222333444555666777',
+    username: 'testuser',
+    global_name: 'Test User',
+    avatar: 'avatar_hash',
+    bot: false,
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordUserSchema rejects missing required fields', () => {
+  const result = DiscordUserSchema.safeParse({
+    id: '222333444555666777',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('DiscordReactionSchema validates correct reaction', () => {
+  const result = DiscordReactionSchema.safeParse({
+    emoji: {
+      name: 'thumbsup',
+    },
+    count: 5,
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordReactionSchema validates reaction with custom emoji', () => {
+  const result = DiscordReactionSchema.safeParse({
+    emoji: {
+      id: '123456789012345678',
+      name: 'custom_emoji',
+    },
+    count: 3,
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordReactionSchema rejects missing required fields', () => {
+  const result = DiscordReactionSchema.safeParse({
+    emoji: {
+      name: 'thumbsup',
+    },
+  })
+  expect(result.success).toBe(false)
+})
+
+test('DiscordFileSchema validates correct file', () => {
+  const result = DiscordFileSchema.safeParse({
+    id: '444555666777888999',
+    filename: 'document.pdf',
+    size: 1024,
+    url: 'https://cdn.discordapp.com/attachments/...',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordFileSchema validates file with optional fields', () => {
+  const result = DiscordFileSchema.safeParse({
+    id: '444555666777888999',
+    filename: 'document.pdf',
+    size: 1024,
+    url: 'https://cdn.discordapp.com/attachments/...',
+    content_type: 'application/pdf',
+    height: 100,
+    width: 100,
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordFileSchema rejects missing required fields', () => {
+  const result = DiscordFileSchema.safeParse({
+    id: '444555666777888999',
+    filename: 'document.pdf',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('DiscordCredentialsSchema validates correct credentials', () => {
+  const result = DiscordCredentialsSchema.safeParse({
+    token: 'token_value',
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordCredentialsSchema rejects missing token', () => {
+  const result = DiscordCredentialsSchema.safeParse({})
+  expect(result.success).toBe(false)
+})
+
+test('DiscordConfigSchema validates correct config', () => {
+  const result = DiscordConfigSchema.safeParse({
+    current_guild: null,
+    token: 'token_value',
+    guilds: {},
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordConfigSchema validates config with guilds', () => {
+  const result = DiscordConfigSchema.safeParse({
+    current_guild: '123456789012345678',
+    token: 'token_value',
+    guilds: {
+      '123456789012345678': {
+        guild_id: '123456789012345678',
+        guild_name: 'Test Guild',
+      },
+    },
+  })
+  expect(result.success).toBe(true)
+})
+
+test('DiscordConfigSchema rejects missing required fields', () => {
+  const result = DiscordConfigSchema.safeParse({
+    current_guild: null,
+    token: 'token_value',
+  })
+  expect(result.success).toBe(false)
+})
+
+test('DiscordError has correct name and code', () => {
+  const error = new DiscordError('Test error', 'TEST_CODE')
+  expect(error.name).toBe('DiscordError')
+  expect(error.message).toBe('Test error')
+  expect(error.code).toBe('TEST_CODE')
+})
+
+test('DiscordError is instance of Error', () => {
+  const error = new DiscordError('Test error', 'TEST_CODE')
+  expect(error instanceof Error).toBe(true)
+})

package/src/platforms/discord/types.ts

@@ -0,0 +1,158 @@
+/**
+ * Core type definitions for Discord platform
+ */
+
+import { z } from 'zod'
+
+export interface DiscordGuild {
+  id: string
+  name: string
+  icon?: string
+  owner?: boolean
+}
+
+export interface DiscordChannel {
+  id: string
+  guild_id: string
+  name: string
+  type: number
+  topic?: string
+  position?: number
+}
+
+export interface DiscordMessage {
+  id: string
+  channel_id: string
+  author: {
+    id: string
+    username: string
+  }
+  content: string
+  timestamp: string
+  edited_timestamp?: string
+  thread_id?: string
+}
+
+export interface DiscordUser {
+  id: string
+  username: string
+  global_name?: string
+  avatar?: string
+  bot?: boolean
+}
+
+export interface DiscordReaction {
+  emoji: {
+    id?: string
+    name: string
+  }
+  count: number
+}
+
+export interface DiscordFile {
+  id: string
+  filename: string
+  size: number
+  url: string
+  content_type?: string
+  height?: number
+  width?: number
+}
+
+export interface DiscordCredentials {
+  token: string
+}
+
+export interface DiscordConfig {
+  current_guild: string | null
+  token: string
+  guilds: Record<
+    string,
+    {
+      guild_id: string
+      guild_name: string
+    }
+  >
+}
+
+// Zod validation schemas
+export const DiscordGuildSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  icon: z.string().optional(),
+  owner: z.boolean().optional(),
+})
+
+export const DiscordChannelSchema = z.object({
+  id: z.string(),
+  guild_id: z.string(),
+  name: z.string(),
+  type: z.number(),
+  topic: z.string().optional(),
+  position: z.number().optional(),
+})
+
+export const DiscordMessageSchema = z.object({
+  id: z.string(),
+  channel_id: z.string(),
+  author: z.object({
+    id: z.string(),
+    username: z.string(),
+  }),
+  content: z.string(),
+  timestamp: z.string(),
+  edited_timestamp: z.string().optional(),
+  thread_id: z.string().optional(),
+})
+
+export const DiscordUserSchema = z.object({
+  id: z.string(),
+  username: z.string(),
+  global_name: z.string().optional(),
+  avatar: z.string().optional(),
+  bot: z.boolean().optional(),
+})
+
+export const DiscordReactionSchema = z.object({
+  emoji: z.object({
+    id: z.string().optional(),
+    name: z.string(),
+  }),
+  count: z.number(),
+})
+
+export const DiscordFileSchema = z.object({
+  id: z.string(),
+  filename: z.string(),
+  size: z.number(),
+  url: z.string(),
+  content_type: z.string().optional(),
+  height: z.number().optional(),
+  width: z.number().optional(),
+})
+
+export const DiscordCredentialsSchema = z.object({
+  token: z.string(),
+})
+
+export const DiscordConfigSchema = z.object({
+  current_guild: z.string().nullable(),
+  token: z.string(),
+  guilds: z.record(
+    z.string(),
+    z.object({
+      guild_id: z.string(),
+      guild_name: z.string(),
+    })
+  ),
+})
+
+export class DiscordError extends Error {
+  code: string
+
+  constructor(message: string, code: string) {
+    super(message)
+    this.name = 'DiscordError'
+    this.code = code
+  }
+}

package/src/platforms/slack/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,
+  userCommand,
+  workspaceCommand,
+} from './commands/index'
+
+const program = new Command()
+
+program
+  .name('agent-slack')
+  .description('CLI tool for Slack communication with token extraction from Slack desktop app')
+  .version(pkg.version)
+  .option('--pretty', 'Pretty-print JSON output')
+  .option('--workspace <id>', 'Use specific workspace')
+
+program.addCommand(authCommand)
+program.addCommand(workspaceCommand)
+program.addCommand(messageCommand)
+program.addCommand(channelCommand)
+program.addCommand(userCommand)
+program.addCommand(reactionCommand)
+program.addCommand(fileCommand)
+program.addCommand(snapshotCommand)
+
+program.parse(process.argv)
+
+export default program