agent-messenger 2.7.0 → 2.9.0

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

@@ -173,10 +173,7 @@ async function usersAction(channel: string, options: { includeBots?: boolean; pr
   }
 }
 
-async function createAction(
-  name: string,
-  options: { private?: boolean; pretty?: boolean },
-): Promise<void> {
+async function createAction(name: string, options: { private?: boolean; pretty?: boolean }): Promise<void> {
   try {
     const credManager = new CredentialManager()
     const workspace = await credManager.getWorkspace()

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

@@ -7,10 +7,12 @@ describe('Emoji Commands', () => {
 
   beforeEach(() => {
     mockClient = {
-      listEmoji: mock(async (): Promise<Record<string, string>> => ({
-        party_blob: 'https://example.com/party_blob.gif',
-        cool_sunglasses: 'https://example.com/cool_sunglasses.png',
-      })),
+      listEmoji: mock(
+        async (): Promise<Record<string, string>> => ({
+          party_blob: 'https://example.com/party_blob.gif',
+          cool_sunglasses: 'https://example.com/cool_sunglasses.png',
+        }),
+      ),
     }
   })
 

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

@@ -6,28 +6,26 @@ import { formatOutput } from '@/shared/utils/output'
 import { SlackClient } from '../client'
 import { CredentialManager } from '../credential-manager'
 
-export const emojiCommand = new Command('emoji')
-  .description('Emoji commands')
-  .addCommand(
-    new Command('list')
-      .description('List all custom emoji in workspace')
-      .option('--pretty', 'Pretty print JSON output')
-      .action(async (options) => {
-        try {
-          const credManager = new CredentialManager()
-          const ws = await credManager.getWorkspace()
+export const emojiCommand = new Command('emoji').description('Emoji commands').addCommand(
+  new Command('list')
+    .description('List all custom emoji in workspace')
+    .option('--pretty', 'Pretty print JSON output')
+    .action(async (options) => {
+      try {
+        const credManager = new CredentialManager()
+        const ws = await credManager.getWorkspace()
 
-          if (!ws) {
-            console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, options.pretty))
-            process.exit(1)
-          }
+        if (!ws) {
+          console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, options.pretty))
+          process.exit(1)
+        }
 
-          const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
-          const emoji = await client.listEmoji()
+        const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
+        const emoji = await client.listEmoji()
 
-          console.log(formatOutput(emoji, options.pretty))
-        } catch (error) {
-          handleError(error as Error)
-        }
-      }),
-  )
+        console.log(formatOutput(emoji, options.pretty))
+      } catch (error) {
+        handleError(error as Error)
+      }
+    }),
+)

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

@@ -270,7 +270,12 @@ async function scheduleAction(
 
     const postAtTimestamp = Number(postAt)
     if (!Number.isInteger(postAtTimestamp) || postAtTimestamp <= 0) {
-      console.log(formatOutput({ error: 'Invalid post-at value. Use a Unix timestamp in seconds (e.g. 1700000000).' }, options.pretty))
+      console.log(
+        formatOutput(
+          { error: 'Invalid post-at value. Use a Unix timestamp in seconds (e.g. 1700000000).' },
+          options.pretty,
+        ),
+      )
       process.exit(1)
     }
 

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

@@ -10,19 +10,21 @@ describe('Pin Commands', () => {
     mockClient = {
       pinMessage: mock(async () => {}),
       unpinMessage: mock(async () => {}),
-      listPins: mock(async (): Promise<SlackPin[]> => [
-        {
-          channel: 'C001',
-          message: {
-            ts: '1234567890.123456',
-            text: 'Pinned message',
-            user: 'U001',
-            type: 'message',
+      listPins: mock(
+        async (): Promise<SlackPin[]> => [
+          {
+            channel: 'C001',
+            message: {
+              ts: '1234567890.123456',
+              text: 'Pinned message',
+              user: 'U001',
+              type: 'message',
+            },
+            date_created: 1234567890,
+            created_by: 'U001',
           },
-          date_created: 1234567890,
-          created_by: 'U001',
-        },
-      ]),
+        ],
+      ),
     }
   })
 

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

@@ -6,11 +6,7 @@ import { formatOutput } from '@/shared/utils/output'
 import { SlackClient } from '../client'
 import { CredentialManager } from '../credential-manager'
 
-async function addAction(
-  text: string,
-  time: string,
-  options: { user?: string; pretty?: boolean },
-): Promise<void> {
+async function addAction(text: string, time: string, options: { user?: string; pretty?: boolean }): Promise<void> {
   try {
     const credManager = new CredentialManager()
     const ws = await credManager.getWorkspace()
@@ -22,7 +18,12 @@ async function addAction(
 
     const timeValue = Number(time)
     if (!Number.isInteger(timeValue) || timeValue <= 0) {
-      console.log(formatOutput({ error: 'Invalid time value. Use a Unix timestamp in seconds (e.g. 1700000000).' }, options.pretty))
+      console.log(
+        formatOutput(
+          { error: 'Invalid time value. Use a Unix timestamp in seconds (e.g. 1700000000).' },
+          options.pretty,
+        ),
+      )
       process.exit(1)
     }
 

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

@@ -34,6 +34,12 @@ test('snapshot command has --limit option', () => {
   expect(hasLimit).toBe(true)
 })
 
+test('snapshot command has --full option', () => {
+  const options = snapshotCommand.options
+  const hasFull = options.some((opt: any) => opt.long === '--full')
+  expect(hasFull).toBe(true)
+})
+
 // Test snapshot logic using spyOn (no global mock pollution)
 let credManagerSpy: ReturnType<typeof spyOn>
 let clientTestAuthSpy: ReturnType<typeof spyOn>
@@ -147,11 +153,66 @@ afterEach(() => {
   clientGetMessagesSpy?.mockRestore()
 })
 
+test('brief snapshot (default) returns workspace, channels as {id, name}, and hint', async () => {
+  const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
+
+  const auth = await client.testAuth()
+  const channels = await client.listChannels()
+  const active = channels.filter((ch) => !ch.is_archived)
+
+  const snapshot = {
+    workspace: {
+      id: auth.team_id,
+      name: auth.team,
+    },
+    channels: active.map((ch) => ({ id: ch.id, name: ch.name })),
+    hint: "Use 'message list <channel>' for messages, 'channel info <channel>' for channel details, 'user list' for users, 'usergroup list' for groups.",
+  }
+
+  expect(snapshot.workspace).toBeDefined()
+  expect(snapshot.workspace.id).toBe('T123')
+  expect(snapshot.workspace.name).toBe('Test Workspace')
+
+  expect(snapshot.channels).toBeDefined()
+  expect(snapshot.channels.length).toBe(2)
+  expect(snapshot.channels[0]).toEqual({ id: 'C123', name: 'general' })
+  expect(snapshot.channels[1]).toEqual({ id: 'C456', name: 'random' })
+
+  expect((snapshot as any).recent_messages).toBeUndefined()
+  expect((snapshot as any).users).toBeUndefined()
+  expect((snapshot as any).usergroups).toBeUndefined()
+
+  expect(snapshot.hint).toContain('message list')
+})
+
+test('brief snapshot excludes archived channels', async () => {
+  const channelsWithArchived: SlackChannel[] = [
+    ...mockChannels,
+    {
+      id: 'C789',
+      name: 'old-channel',
+      is_private: false,
+      is_archived: true,
+      created: 1234567800,
+      creator: 'U123',
+      topic: { value: 'Archived', creator: 'U123', last_set: 1234567800 },
+      purpose: { value: 'Old channel', creator: 'U123', last_set: 1234567800 },
+    },
+  ]
+
+  clientListChannelsSpy.mockResolvedValue(channelsWithArchived)
+
+  const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
+  const channels = await client.listChannels()
+  const active = channels.filter((ch) => !ch.is_archived)
+
+  expect(active.length).toBe(2)
+  expect(active.every((ch) => !ch.is_archived)).toBe(true)
+})
+
 test('full snapshot returns workspace, channels, messages, and users', async () => {
-  const credManager = new CredentialManager()
   const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
 
-  const _workspace = await credManager.getWorkspace()
   const auth = await client.testAuth()
   const channels = await client.listChannels()
   const users = await client.listUsers()
@@ -218,10 +279,8 @@ test('full snapshot returns workspace, channels, messages, and users', async ()
 })
 
 test('snapshot with --channels-only excludes messages and users', async () => {
-  const credManager = new CredentialManager()
   const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
 
-  const _workspace = await credManager.getWorkspace()
   const auth = await client.testAuth()
   const channels = await client.listChannels()
 
@@ -249,10 +308,8 @@ test('snapshot with --channels-only excludes messages and users', async () => {
 })
 
 test('snapshot with --users-only excludes channels and messages', async () => {
-  const credManager = new CredentialManager()
   const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
 
-  const _workspace = await credManager.getWorkspace()
   const auth = await client.testAuth()
   const users = await client.listUsers()
 
@@ -279,10 +336,8 @@ test('snapshot with --users-only excludes channels and messages', async () => {
 })
 
 test('snapshot respects --limit option for messages', async () => {
-  const credManager = new CredentialManager()
   const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
 
-  const _workspace = await credManager.getWorkspace()
   const auth = await client.testAuth()
   const channels = await client.listChannels()
 

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

@@ -11,6 +11,7 @@ import type { SlackChannel } from '../types'
 async function snapshotAction(options: {
   channelsOnly?: boolean
   usersOnly?: boolean
+  full?: boolean
   limit?: number
   pretty?: boolean
 }): Promise<void> {
@@ -26,7 +27,6 @@ async function snapshotAction(options: {
     const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
 
     const auth = await client.testAuth()
-    const messageLimit = options.limit || 20
 
     const snapshot: Record<string, any> = {
       workspace: {
@@ -35,88 +35,120 @@ async function snapshotAction(options: {
       },
     }
 
-    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,
-        }))
-      }
+    const isFull = options.full || options.channelsOnly || options.usersOnly
+    if (isFull) {
+      await buildFullSnapshot(client, snapshot, options)
+    } else {
+      await buildBriefSnapshot(client, snapshot, options)
     }
 
-    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)
+  }
+}
 
-    if (!options.channelsOnly && !options.usersOnly) {
-      const usergroups = await client.listUsergroups({ includeUsers: true, includeCount: true })
+async function buildBriefSnapshot(
+  client: SlackClient,
+  snapshot: Record<string, any>,
+  options: { channelsOnly?: boolean; usersOnly?: boolean },
+): Promise<void> {
+  if (!options.usersOnly) {
+    const channels = await client.listChannels()
+    const active = channels.filter((ch) => !ch.is_archived)
+    snapshot.channels = active.map((ch) => ({ id: ch.id, name: ch.name }))
+  }
 
-      snapshot.usergroups = usergroups.map((ug) => ({
-        id: ug.id,
-        name: ug.name,
-        handle: ug.handle,
-        description: ug.description,
-        user_count: ug.user_count,
-        users: ug.users,
+  snapshot.hint =
+    "Use 'message list <channel>' for messages, 'channel info <channel>' for channel details, 'user list' for users, 'usergroup list' for groups."
+}
+
+async function buildFullSnapshot(
+  client: SlackClient,
+  snapshot: Record<string, any>,
+  options: { channelsOnly?: boolean; usersOnly?: boolean; limit?: number },
+): Promise<void> {
+  const messageLimit = options.limit || 20
+
+  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,
       }))
     }
+  }
 
-    console.log(formatOutput(snapshot, options.pretty))
-  } catch (error) {
-    handleError(error as Error)
+  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,
+    }))
+  }
+
+  if (!options.channelsOnly && !options.usersOnly) {
+    const usergroups = await client.listUsergroups({ includeUsers: true, includeCount: true })
+
+    snapshot.usergroups = usergroups.map((ug) => ({
+      id: ug.id,
+      name: ug.name,
+      handle: ug.handle,
+      description: ug.description,
+      user_count: ug.user_count,
+      users: ug.users,
+    }))
   }
 }
 
 export const snapshotCommand = new Command('snapshot')
-  .description('Get comprehensive workspace state for AI agents')
+  .description('Get workspace overview for AI agents (brief by default, use --full for comprehensive data)')
+  .option('--full', 'Include messages, users, and user groups (verbose)')
   .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')
+  .option('--limit <n>', 'Number of recent messages per channel with --full (default: 20)', '20')
   .action(async (options) => {
     await snapshotAction({
       channelsOnly: options.channelsOnly,
       usersOnly: options.usersOnly,
+      full: options.full,
       limit: parseInt(options.limit, 10),
       pretty: options.pretty,
     })

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

@@ -174,7 +174,12 @@ export const userCommand = new Command('user')
               ? (() => {
                   const ts = Number(options.expiration)
                   if (!Number.isInteger(ts) || ts <= 0) {
-                    console.log(formatOutput({ error: 'Invalid --expiration value. Use a Unix timestamp in seconds.' }, options.pretty))
+                    console.log(
+                      formatOutput(
+                        { error: 'Invalid --expiration value. Use a Unix timestamp in seconds.' },
+                        options.pretty,
+                      ),
+                    )
                     process.exit(1)
                   }
                   return ts

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

@@ -86,9 +86,9 @@ describe('Usergroup Commands', () => {
       mockClient.updateUsergroup = mock(async () => {
         throw new Error('no_such_subteam')
       })
-      await expect(
-        (mockClient as SlackClient).updateUsergroup('S999', { name: 'Nope' }),
-      ).rejects.toThrow('no_such_subteam')
+      await expect((mockClient as SlackClient).updateUsergroup('S999', { name: 'Nope' })).rejects.toThrow(
+        'no_such_subteam',
+      )
     })
   })
 

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

@@ -18,7 +18,11 @@ async function getClient(pretty?: boolean): Promise<SlackClient | null> {
   return await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
 }
 
-async function listAction(options: { includeDisabled?: boolean; includeUsers?: boolean; pretty?: boolean }): Promise<void> {
+async function listAction(options: {
+  includeDisabled?: boolean
+  includeUsers?: boolean
+  pretty?: boolean
+}): Promise<void> {
   try {
     const client = await getClient(options.pretty)
     if (!client) return process.exit(1)
@@ -136,7 +140,10 @@ async function disableAction(usergroupId: string, options: { pretty?: boolean })
   }
 }
 
-async function membersAction(usergroupId: string, options: { includeDisabled?: boolean; pretty?: boolean }): Promise<void> {
+async function membersAction(
+  usergroupId: string,
+  options: { includeDisabled?: boolean; pretty?: boolean },
+): Promise<void> {
   try {
     const client = await getClient(options.pretty)
     if (!client) return process.exit(1)
@@ -151,11 +158,7 @@ async function membersAction(usergroupId: string, options: { includeDisabled?: b
   }
 }
 
-async function membersUpdateAction(
-  usergroupId: string,
-  users: string,
-  options: { pretty?: boolean },
-): Promise<void> {
+async function membersUpdateAction(usergroupId: string, users: string, options: { pretty?: boolean }): Promise<void> {
   try {
     const client = await getClient(options.pretty)
     if (!client) return process.exit(1)

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

@@ -1,8 +1,8 @@
 import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
 
 import { SlackClient } from '@/platforms/slack/client'
-import { CredentialManager } from '@/platforms/slack/credential-manager'
 import { whoamiAction, whoamiCommand } from '@/platforms/slack/commands/whoami'
+import { CredentialManager } from '@/platforms/slack/credential-manager'
 
 let credManagerSpy: ReturnType<typeof spyOn>
 let clientTestAuthSpy: ReturnType<typeof spyOn>

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

@@ -1,6 +1,8 @@
 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'
 

package/src/platforms/slack/index.ts

@@ -43,5 +43,3 @@ export {
   WorkspaceCredentialsSchema,
   ConfigSchema,
 } from './types'
-
-

package/src/platforms/slack/listener.test.ts

@@ -16,6 +16,7 @@ class MockWs {
   sent: string[] = []
 
   constructor(_url: string, _options?: any) {
+    // oxlint-disable-next-line typescript-eslint/no-this-alias
     mockWsInstance = this
   }
 

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

@@ -813,10 +813,7 @@ describe('TokenExtractor browser fallback', () => {
     mkdirSync(leveldbDir, { recursive: true })
     writeFileSync(join(leveldbDir, '000001.log'), `"${token}"T12345678"name":"desktop-workspace"`)
 
-    const extractFromBrowsersSpy = spyOn(
-      TokenExtractor.prototype as any,
-      'extractFromBrowsers',
-    ).mockResolvedValue([])
+    const extractFromBrowsersSpy = spyOn(TokenExtractor.prototype as any, 'extractFromBrowsers').mockResolvedValue([])
 
     // when
     const extractor = new TokenExtractor('darwin', slackDir)
@@ -843,10 +840,9 @@ describe('TokenExtractor browser fallback', () => {
       cookie: '',
     }
 
-    const extractFromBrowsersSpy = spyOn(
-      TokenExtractor.prototype as any,
-      'extractFromBrowsers',
-    ).mockResolvedValue([browserWorkspace])
+    const extractFromBrowsersSpy = spyOn(TokenExtractor.prototype as any, 'extractFromBrowsers').mockResolvedValue([
+      browserWorkspace,
+    ])
 
     // when
     const extractor = new TokenExtractor('darwin', slackDir)
@@ -871,10 +867,9 @@ describe('TokenExtractor browser fallback', () => {
       cookie: 'xoxd-browser-cookie',
     }
 
-    const extractFromBrowsersSpy = spyOn(
-      TokenExtractor.prototype as any,
-      'extractFromBrowsers',
-    ).mockResolvedValue([browserWorkspace])
+    const extractFromBrowsersSpy = spyOn(TokenExtractor.prototype as any, 'extractFromBrowsers').mockResolvedValue([
+      browserWorkspace,
+    ])
 
     // when
     const extractor = new TokenExtractor('darwin', slackDir)