agent-messenger 2.7.0 → 2.9.0

package/src/platforms/channeltalkbot/client.ts

@@ -1,3 +1,5 @@
+import { ChannelBotCredentialManager } from './credential-manager'
+import { wrapTextInBlocks } from './message-utils'
 import type {
   ChannelBotBot,
   ChannelBotChannel,
@@ -9,8 +11,6 @@ import type {
   MessageBlock,
 } from './types'
 import { ChannelBotError as ChannelBotErrorClass } from './types'
-import { wrapTextInBlocks } from './message-utils'
-import { ChannelBotCredentialManager } from './credential-manager'
 
 const BASE_URL = 'https://api.channel.io/open/v5'
 const MAX_RETRIES = 3
@@ -82,7 +82,12 @@ export class ChannelBotClient {
       limit?: number
     },
   ): Promise<ChannelBotMessage[]> {
-    return this.request<ChannelBotMessage[]>('GET', this.buildPath(`/user-chats/${chatId}/messages`, params), undefined, 'messages')
+    return this.request<ChannelBotMessage[]>(
+      'GET',
+      this.buildPath(`/user-chats/${chatId}/messages`, params),
+      undefined,
+      'messages',
+    )
   }
 
   async sendUserChatMessage(chatId: string, blocks: MessageBlock[], botName?: string): Promise<ChannelBotMessage> {
@@ -95,7 +100,12 @@ export class ChannelBotClient {
   }
 
   async closeUserChat(chatId: string, botName: string): Promise<ChannelBotUserChat> {
-    return this.request<ChannelBotUserChat>('PATCH', this.buildPath(`/user-chats/${chatId}/close`, { botName }), undefined, 'userChat')
+    return this.request<ChannelBotUserChat>(
+      'PATCH',
+      this.buildPath(`/user-chats/${chatId}/close`, { botName }),
+      undefined,
+      'userChat',
+    )
   }
 
   async deleteUserChat(chatId: string): Promise<void> {
@@ -129,7 +139,12 @@ export class ChannelBotClient {
       limit?: number
     },
   ): Promise<ChannelBotMessage[]> {
-    return this.request<ChannelBotMessage[]>('GET', this.buildPath(`/groups/${groupId}/messages`, params), undefined, 'messages')
+    return this.request<ChannelBotMessage[]>(
+      'GET',
+      this.buildPath(`/groups/${groupId}/messages`, params),
+      undefined,
+      'messages',
+    )
   }
 
   async sendGroupMessage(groupId: string, blocks: MessageBlock[], botName?: string): Promise<ChannelBotMessage> {
@@ -165,10 +180,15 @@ export class ChannelBotClient {
   }
 
   async createBot(name: string, options?: { color?: string; avatarUrl?: string }): Promise<ChannelBotBot> {
-    return this.request<ChannelBotBot>('POST', '/bots', {
-      name,
-      ...options,
-    }, 'bot')
+    return this.request<ChannelBotBot>(
+      'POST',
+      '/bots',
+      {
+        name,
+        ...options,
+      },
+      'bot',
+    )
   }
 
   async deleteBot(botId: string): Promise<void> {
@@ -265,19 +285,25 @@ export class ChannelBotClient {
           continue
         }
 
-        const errorBody = await response.json().catch(() => ({})) as {
+        const errorBody = (await response.json().catch(() => ({}))) as {
           message?: string
           code?: string
         }
-        throw new ChannelBotErrorClass(errorBody.message || `HTTP ${response.status}`, errorBody.code || `http_${response.status}`)
+        throw new ChannelBotErrorClass(
+          errorBody.message || `HTTP ${response.status}`,
+          errorBody.code || `http_${response.status}`,
+        )
       }
 
       if (!response.ok) {
-        const errorBody = await response.json().catch(() => ({})) as {
+        const errorBody = (await response.json().catch(() => ({}))) as {
           message?: string
           code?: string
         }
-        throw new ChannelBotErrorClass(errorBody.message || `HTTP ${response.status}`, errorBody.code || `http_${response.status}`)
+        throw new ChannelBotErrorClass(
+          errorBody.message || `HTTP ${response.status}`,
+          errorBody.code || `http_${response.status}`,
+        )
       }
 
       if (response.status === 204) {

package/src/platforms/channeltalkbot/commands/auth.test.ts

@@ -13,7 +13,9 @@ const mockGetChannel = mock(() =>
 
 mock.module('../client', () => ({
   ChannelBotClient: class MockChannelBotClient {
-    async login(_credentials?: any) { return this }
+    async login(_credentials?: any) {
+      return this
+    }
     getChannel = mockGetChannel
   },
 }))

package/src/platforms/channeltalkbot/commands/auth.ts

@@ -66,7 +66,10 @@ export async function statusAction(options: ActionOptions): Promise<ActionResult
     let workspaceName: string | undefined
 
     try {
-      const client = await new ChannelBotClient().login({ accessKey: creds.access_key, accessSecret: creds.access_secret })
+      const client = await new ChannelBotClient().login({
+        accessKey: creds.access_key,
+        accessSecret: creds.access_secret,
+      })
       const channel = await client.getChannel()
       valid = true
       workspaceId = channel.id

package/src/platforms/channeltalkbot/commands/bot.test.ts

@@ -6,14 +6,18 @@ import { join } from 'node:path'
 
 const mockListBots = mock(() =>
   Promise.resolve([
-    { id: 'bot1', channelId: 'ch1', name: 'Support Bot', avatarUrl: 'https://example.com/avatar.png', color: '#FF0000' },
+    {
+      id: 'bot1',
+      channelId: 'ch1',
+      name: 'Support Bot',
+      avatarUrl: 'https://example.com/avatar.png',
+      color: '#FF0000',
+    },
     { id: 'bot2', channelId: 'ch1', name: 'Sales Bot' },
   ]),
 )
 
-const mockCreateBot = mock(() =>
-  Promise.resolve({ id: 'bot3', channelId: 'ch1', name: 'New Bot', color: '#00FF00' }),
-)
+const mockCreateBot = mock(() => Promise.resolve({ id: 'bot3', channelId: 'ch1', name: 'New Bot', color: '#00FF00' }))
 
 const mockDeleteBot = mock(() => Promise.resolve(undefined))
 
@@ -86,7 +90,11 @@ describe('bot commands', () => {
 
     test('creates bot with optional color and avatar', async () => {
       const manager = new ChannelBotCredentialManager(tempDir)
-      await createAction('New Bot', { color: '#00FF00', avatarUrl: 'https://example.com/avatar.png', _credManager: manager })
+      await createAction('New Bot', {
+        color: '#00FF00',
+        avatarUrl: 'https://example.com/avatar.png',
+        _credManager: manager,
+      })
 
       expect(capturedCreateArgs[1]).toMatchObject({ color: '#00FF00', avatarUrl: 'https://example.com/avatar.png' })
     })

package/src/platforms/channeltalkbot/commands/message.test.ts

@@ -115,12 +115,12 @@ describe('message commands', () => {
   describe('sendAction', () => {
     test('sends to userchat and wraps text in blocks', async () => {
       const manager = new ChannelBotCredentialManager(tempDir)
-        const result = await sendAction('chat1', 'Hello world', { type: 'userchat', _credManager: manager })
+      const result = await sendAction('chat1', 'Hello world', { type: 'userchat', _credManager: manager })
 
-        expect(result.error).toBeUndefined()
-        expect(result.id).toBe('msg1')
-        expect(capturedSendUserChatArgs[1]).toEqual([{ type: 'text', value: 'Hello world' }])
-      })
+      expect(result.error).toBeUndefined()
+      expect(result.id).toBe('msg1')
+      expect(capturedSendUserChatArgs[1]).toEqual([{ type: 'text', value: 'Hello world' }])
+    })
 
     test('sends to group when type=group', async () => {
       const manager = new ChannelBotCredentialManager(tempDir)
@@ -167,7 +167,13 @@ describe('message commands', () => {
 
     test('passes pagination params', async () => {
       const manager = new ChannelBotCredentialManager(tempDir)
-      await listAction('chat1', { type: 'userchat', limit: '10', sort: 'asc', since: 'cursor123', _credManager: manager })
+      await listAction('chat1', {
+        type: 'userchat',
+        limit: '10',
+        sort: 'asc',
+        since: 'cursor123',
+        _credManager: manager,
+      })
 
       expect(capturedGetUserChatMsgArgs[0]).toBe('chat1')
       expect(capturedGetUserChatMsgArgs[1]).toMatchObject({ limit: 10, sortOrder: 'asc', since: 'cursor123' })

package/src/platforms/channeltalkbot/commands/shared.ts

@@ -15,7 +15,9 @@ export async function getClient(options: WorkspaceOption): Promise<ChannelBotCli
   const creds = await credManager.getCredentials(options.workspace)
 
   if (!creds) {
-    console.log(formatOutput({ error: 'No credentials. Run "auth set <access-key> <access-secret>" first.' }, options.pretty))
+    console.log(
+      formatOutput({ error: 'No credentials. Run "auth set <access-key> <access-secret>" first.' }, options.pretty),
+    )
     process.exit(1)
   }
 
@@ -29,7 +31,9 @@ export async function getCurrentWorkspace(options: WorkspaceOption): Promise<str
   const creds = await credManager.getCredentials()
 
   if (!creds) {
-    console.log(formatOutput({ error: 'No workspace set. Run "auth set <access-key> <access-secret>" first.' }, options.pretty))
+    console.log(
+      formatOutput({ error: 'No workspace set. Run "auth set <access-key> <access-secret>" first.' }, options.pretty),
+    )
     process.exit(1)
   }
 

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

@@ -4,12 +4,24 @@ import { mkdir } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-const mockGetChannel = mock(() => Promise.resolve({ id: 'ch1', name: 'Test Workspace', homepageUrl: 'https://example.com' }))
+const mockGetChannel = mock(() =>
+  Promise.resolve({ id: 'ch1', name: 'Test Workspace', homepageUrl: 'https://example.com' }),
+)
 const mockListGroups = mock(() => Promise.resolve([{ id: 'grp1', channelId: 'ch1', name: 'Team Alpha' }]))
-const mockGetGroupMessages = mock(() => Promise.resolve([{ id: 'msg1', chatId: 'grp1', personType: 'manager' as const, plainText: 'Hello', createdAt: 1234567890 }]))
-const mockListUserChats = mock(() => Promise.resolve([{ id: 'chat1', channelId: 'ch1', state: 'opened' as const, userId: 'user1' }]))
-const mockGetUserChatMessages = mock(() => Promise.resolve([{ id: 'msg2', chatId: 'chat1', plainText: 'Hi', createdAt: 1234567890 }]))
-const mockListManagers = mock(() => Promise.resolve([{ id: 'mgr1', channelId: 'ch1', name: 'Alice', description: 'Lead' }]))
+const mockGetGroupMessages = mock(() =>
+  Promise.resolve([
+    { id: 'msg1', chatId: 'grp1', personType: 'manager' as const, plainText: 'Hello', createdAt: 1234567890 },
+  ]),
+)
+const mockListUserChats = mock(() =>
+  Promise.resolve([{ id: 'chat1', channelId: 'ch1', state: 'opened' as const, userId: 'user1' }]),
+)
+const mockGetUserChatMessages = mock(() =>
+  Promise.resolve([{ id: 'msg2', chatId: 'chat1', plainText: 'Hi', createdAt: 1234567890 }]),
+)
+const mockListManagers = mock(() =>
+  Promise.resolve([{ id: 'mgr1', channelId: 'ch1', name: 'Alice', description: 'Lead' }]),
+)
 const mockListBots = mock(() => Promise.resolve([{ id: 'bot1', channelId: 'ch1', name: 'Support Bot' }]))
 
 mock.module('../client', () => ({
@@ -55,10 +67,28 @@ describe('snapshot command', () => {
   })
 
   describe('snapshotAction', () => {
-    test('returns workspace, groups, user_chats, managers, bots', async () => {
+    test('brief snapshot returns workspace, groups (names), chat counts, and hint', async () => {
       const manager = new ChannelBotCredentialManager(tempDir)
       const result = await snapshotAction({ _credManager: manager })
 
+      expect(result.error).toBeUndefined()
+      expect(result.workspace).toBeDefined()
+      expect(result.workspace?.id).toBe('ch1')
+      expect(result.workspace?.name).toBe('Test Workspace')
+      expect(result.groups).toBeDefined()
+      expect(result.groups?.[0]).toEqual({ id: 'grp1', name: 'Team Alpha' })
+      expect(result.user_chats).toBeDefined()
+      expect(result.user_chats?.opened_count).toBe(1)
+      expect(result.hint).toBeDefined()
+      expect(result.managers).toBeUndefined()
+      expect(result.bots).toBeUndefined()
+      expect(mockGetGroupMessages).not.toHaveBeenCalled()
+    })
+
+    test('full snapshot returns workspace, groups, user_chats, managers, bots', async () => {
+      const manager = new ChannelBotCredentialManager(tempDir)
+      const result = await snapshotAction({ full: true, _credManager: manager })
+
       expect(result.error).toBeUndefined()
       expect(result.workspace).toBeDefined()
       expect(result.workspace?.id).toBe('ch1')
@@ -71,7 +101,7 @@ describe('snapshot command', () => {
 
     test('groups-only flag skips user_chats, managers, bots', async () => {
       const manager = new ChannelBotCredentialManager(tempDir)
-      const result = await snapshotAction({ groupsOnly: true, _credManager: manager })
+      const result = await snapshotAction({ full: true, groupsOnly: true, _credManager: manager })
 
       expect(result.error).toBeUndefined()
       expect(result.workspace).toBeDefined()
@@ -83,7 +113,7 @@ describe('snapshot command', () => {
 
     test('chats-only flag skips groups, managers, bots', async () => {
       const manager = new ChannelBotCredentialManager(tempDir)
-      const result = await snapshotAction({ chatsOnly: true, _credManager: manager })
+      const result = await snapshotAction({ full: true, chatsOnly: true, _credManager: manager })
 
       expect(result.error).toBeUndefined()
       expect(result.workspace).toBeDefined()
@@ -93,21 +123,21 @@ describe('snapshot command', () => {
       expect(result.bots).toBeUndefined()
     })
 
-    test('groups include recent messages', async () => {
+    test('full groups include recent messages', async () => {
       const manager = new ChannelBotCredentialManager(tempDir)
-      const result = await snapshotAction({ groupsOnly: true, limit: 3, _credManager: manager })
+      const result = await snapshotAction({ full: true, groupsOnly: true, limit: 3, _credManager: manager })
 
       expect(result.groups?.[0].messages).toBeDefined()
       expect(result.groups?.[0].messages?.[0].id).toBe('msg1')
     })
 
-    test('user_chats includes counts and recent opened', async () => {
+    test('full user_chats includes counts and recent opened', async () => {
       const manager = new ChannelBotCredentialManager(tempDir)
-      const result = await snapshotAction({ chatsOnly: true, _credManager: manager })
+      const result = await snapshotAction({ full: true, chatsOnly: true, _credManager: manager })
 
       expect(result.user_chats?.opened_count).toBe(1)
       expect(result.user_chats?.recent_opened).toHaveLength(1)
-      expect(result.user_chats?.recent_opened[0].id).toBe('chat1')
+      expect(result.user_chats?.recent_opened?.[0].id).toBe('chat1')
     })
   })
 })

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

@@ -9,6 +9,7 @@ import { getClient } from './shared'
 interface SnapshotOption extends WorkspaceOption {
   groupsOnly?: boolean
   chatsOnly?: boolean
+  full?: boolean
   limit?: number
 }
 
@@ -33,7 +34,7 @@ interface SnapshotResult {
     opened_count: number
     snoozed_count: number
     closed_count: number
-    recent_opened: Array<{
+    recent_opened?: Array<{
       id: string
       name?: string
       user_id?: string
@@ -46,13 +47,13 @@ interface SnapshotResult {
   }
   managers?: Array<{ id: string; name: string; description?: string }>
   bots?: Array<{ id: string; name: string }>
+  hint?: string
   error?: string
 }
 
 export async function snapshotAction(options: SnapshotOption): Promise<SnapshotResult> {
   try {
     const client = await getClient(options)
-    const limit = options.limit ?? 5
 
     const channel = await client.getChannel()
     const workspace = {
@@ -62,71 +63,75 @@ export async function snapshotAction(options: SnapshotOption): Promise<SnapshotR
       description: channel.description,
     }
 
-    if (options.groupsOnly) {
-      const groups = await client.listGroups({ limit: 20 })
-      const groupsWithMessages = await Promise.all(
-        groups.map(async (g) => {
-          const messages = await client.getGroupMessages(g.id, { limit, sortOrder: 'desc' })
-          return {
-            id: g.id,
-            name: g.name,
-            messages: messages.map((m) => ({
-              id: m.id,
-              person_type: m.personType,
-              plain_text: m.plainText,
-              created_at: m.createdAt,
-            })),
-          }
-        }),
-      )
-      return { workspace, groups: groupsWithMessages }
+    if (options.full) {
+      return buildFullSnapshot(client, workspace, options)
     }
 
-    if (options.chatsOnly) {
-      const [openedChats, snoozedChats, closedChats] = await Promise.all([
-        client.listUserChats({ state: 'opened', limit: 10, sortOrder: 'desc' }),
-        client.listUserChats({ state: 'snoozed', limit: 1 }),
-        client.listUserChats({ state: 'closed', limit: 1 }),
-      ])
-
-      const recentOpened = await Promise.all(
-        openedChats.slice(0, 5).map(async (chat) => {
-          const messages = await client.getUserChatMessages(chat.id, { limit: 1, sortOrder: 'desc' })
-          return {
-            id: chat.id,
-            name: chat.name,
-            user_id: chat.userId,
-            last_message: messages[0]
-              ? {
-                  id: messages[0].id,
-                  plain_text: messages[0].plainText,
-                  created_at: messages[0].createdAt,
-                }
-              : undefined,
-          }
-        }),
-      )
+    return buildBriefSnapshot(client, workspace, options)
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
 
-      return {
-        workspace,
-        user_chats: {
-          opened_count: openedChats.length,
-          snoozed_count: snoozedChats.length,
-          closed_count: closedChats.length,
-          recent_opened: recentOpened,
-        },
-      }
+async function buildBriefSnapshot(
+  client: Awaited<ReturnType<typeof getClient>>,
+  workspace: SnapshotResult['workspace'],
+  options: SnapshotOption,
+): Promise<SnapshotResult> {
+  if (options.groupsOnly) {
+    const groups = await client.listGroups({ limit: 20 })
+    return {
+      workspace,
+      groups: groups.map((g) => ({ id: g.id, name: g.name })),
+      hint: "Use 'group messages <group>' for messages.",
     }
+  }
 
-    const [groups, openedChats, snoozedChats, closedChats, managers, bots] = await Promise.all([
-      client.listGroups({ limit: 20 }),
+  if (options.chatsOnly) {
+    const [openedChats, snoozedChats, closedChats] = await Promise.all([
       client.listUserChats({ state: 'opened', limit: 10, sortOrder: 'desc' }),
       client.listUserChats({ state: 'snoozed', limit: 1 }),
       client.listUserChats({ state: 'closed', limit: 1 }),
-      client.listManagers({ limit: 50 }),
-      client.listBots({ limit: 50 }),
     ])
+    return {
+      workspace,
+      user_chats: {
+        opened_count: openedChats.length,
+        snoozed_count: snoozedChats.length,
+        closed_count: closedChats.length,
+      },
+      hint: "Use 'chat list --state opened' for chat details, 'chat messages <chat>' for messages.",
+    }
+  }
+
+  const [groups, openedChats, snoozedChats, closedChats] = await Promise.all([
+    client.listGroups({ limit: 20 }),
+    client.listUserChats({ state: 'opened', limit: 10, sortOrder: 'desc' }),
+    client.listUserChats({ state: 'snoozed', limit: 1 }),
+    client.listUserChats({ state: 'closed', limit: 1 }),
+  ])
+
+  return {
+    workspace,
+    groups: groups.map((g) => ({ id: g.id, name: g.name })),
+    user_chats: {
+      opened_count: openedChats.length,
+      snoozed_count: snoozedChats.length,
+      closed_count: closedChats.length,
+    },
+    hint: "Use 'group messages <group>' for group messages, 'chat list --state opened' for chats, 'manager list' for managers.",
+  }
+}
+
+async function buildFullSnapshot(
+  client: Awaited<ReturnType<typeof getClient>>,
+  workspace: SnapshotResult['workspace'],
+  options: SnapshotOption,
+): Promise<SnapshotResult> {
+  const limit = options.limit ?? 5
 
+  if (options.groupsOnly) {
+    const groups = await client.listGroups({ limit: 20 })
     const groupsWithMessages = await Promise.all(
       groups.map(async (g) => {
         const messages = await client.getGroupMessages(g.id, { limit, sortOrder: 'desc' })
@@ -142,6 +147,15 @@ export async function snapshotAction(options: SnapshotOption): Promise<SnapshotR
         }
       }),
     )
+    return { workspace, groups: groupsWithMessages }
+  }
+
+  if (options.chatsOnly) {
+    const [openedChats, snoozedChats, closedChats] = await Promise.all([
+      client.listUserChats({ state: 'opened', limit: 10, sortOrder: 'desc' }),
+      client.listUserChats({ state: 'snoozed', limit: 1 }),
+      client.listUserChats({ state: 'closed', limit: 1 }),
+    ])
 
     const recentOpened = await Promise.all(
       openedChats.slice(0, 5).map(async (chat) => {
@@ -163,26 +177,78 @@ export async function snapshotAction(options: SnapshotOption): Promise<SnapshotR
 
     return {
       workspace,
-      groups: groupsWithMessages,
       user_chats: {
         opened_count: openedChats.length,
         snoozed_count: snoozedChats.length,
         closed_count: closedChats.length,
         recent_opened: recentOpened,
       },
-      managers: managers.map((m) => ({ id: m.id, name: m.name, description: m.description })),
-      bots: bots.map((b) => ({ id: b.id, name: b.name })),
     }
-  } catch (error) {
-    return { error: (error as Error).message }
+  }
+
+  const [groups, openedChats, snoozedChats, closedChats, managers, bots] = await Promise.all([
+    client.listGroups({ limit: 20 }),
+    client.listUserChats({ state: 'opened', limit: 10, sortOrder: 'desc' }),
+    client.listUserChats({ state: 'snoozed', limit: 1 }),
+    client.listUserChats({ state: 'closed', limit: 1 }),
+    client.listManagers({ limit: 50 }),
+    client.listBots({ limit: 50 }),
+  ])
+
+  const groupsWithMessages = await Promise.all(
+    groups.map(async (g) => {
+      const messages = await client.getGroupMessages(g.id, { limit, sortOrder: 'desc' })
+      return {
+        id: g.id,
+        name: g.name,
+        messages: messages.map((m) => ({
+          id: m.id,
+          person_type: m.personType,
+          plain_text: m.plainText,
+          created_at: m.createdAt,
+        })),
+      }
+    }),
+  )
+
+  const recentOpened = await Promise.all(
+    openedChats.slice(0, 5).map(async (chat) => {
+      const messages = await client.getUserChatMessages(chat.id, { limit: 1, sortOrder: 'desc' })
+      return {
+        id: chat.id,
+        name: chat.name,
+        user_id: chat.userId,
+        last_message: messages[0]
+          ? {
+              id: messages[0].id,
+              plain_text: messages[0].plainText,
+              created_at: messages[0].createdAt,
+            }
+          : undefined,
+      }
+    }),
+  )
+
+  return {
+    workspace,
+    groups: groupsWithMessages,
+    user_chats: {
+      opened_count: openedChats.length,
+      snoozed_count: snoozedChats.length,
+      closed_count: closedChats.length,
+      recent_opened: recentOpened,
+    },
+    managers: managers.map((m) => ({ id: m.id, name: m.name, description: m.description })),
+    bots: bots.map((b) => ({ id: b.id, name: b.name })),
   }
 }
 
 export const snapshotCommand = new Command('snapshot')
-  .description('Workspace overview for AI agent context')
+  .description('Workspace overview for AI agents (brief by default, use --full for comprehensive data)')
+  .option('--full', 'Include messages, managers, and bots (verbose)')
   .option('--groups-only', 'List groups only, skip user chats')
   .option('--chats-only', 'List user chats only, skip groups')
-  .option('--limit <n>', 'Messages per group/chat (default: 5)', '5')
+  .option('--limit <n>', 'Messages per group/chat with --full (default: 5)', '5')
   .option('--workspace <id>', 'Workspace ID')
   .option('--bot <name>', 'Bot name')
   .option('--pretty', 'Pretty print JSON output')
@@ -190,6 +256,7 @@ export const snapshotCommand = new Command('snapshot')
     try {
       const result = await snapshotAction({
         ...options,
+        full: options.full,
         limit: parseInt(options.limit, 10),
       })
       console.log(formatOutput(result, options.pretty))

package/src/platforms/channeltalkbot/credential-manager.test.ts

@@ -53,7 +53,7 @@ describe('ChannelBotCredentialManager', () => {
       const config = {
         current: { workspace_id: 'ch_abc123' },
         workspaces: {
-          'ch_abc123': {
+          ch_abc123: {
             workspace_id: 'ch_abc123',
             workspace_name: 'Test Workspace',
             access_key: 'test-key',

package/src/platforms/channeltalkbot/index.test.ts

@@ -72,5 +72,3 @@ test('ChannelBotWorkspaceEntrySchema is exported from barrel', () => {
 test('MessageBlockSchema is exported from barrel', () => {
   expect(typeof MessageBlockSchema.parse).toBe('function')
 })
-
-

package/src/platforms/channeltalkbot/index.ts

@@ -27,4 +27,3 @@ export {
   ChannelBotWorkspaceEntrySchema,
   MessageBlockSchema,
 } from './types'
-

package/src/platforms/discord/commands/auth.test.ts

@@ -1,9 +1,9 @@
 import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
 
-import { getNoDiscordTokenFoundMessage } from './auth'
 import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
 import { DiscordTokenExtractor } from '../token-extractor'
+import { getNoDiscordTokenFoundMessage } from './auth'
 
 let extractorExtractSpy: ReturnType<typeof spyOn>
 let clientTestAuthSpy: ReturnType<typeof spyOn>
@@ -14,9 +14,11 @@ let credManagerClearTokenSpy: ReturnType<typeof spyOn>
 
 beforeEach(() => {
   // Spy on DiscordTokenExtractor.prototype.extract
-  extractorExtractSpy = spyOn(DiscordTokenExtractor.prototype, 'extract').mockResolvedValue([{
-    token: 'test-token-123',
-  }])
+  extractorExtractSpy = spyOn(DiscordTokenExtractor.prototype, 'extract').mockResolvedValue([
+    {
+      token: 'test-token-123',
+    },
+  ])
 
   // Spy on DiscordClient.prototype methods
   clientTestAuthSpy = spyOn(DiscordClient.prototype, 'testAuth').mockResolvedValue({