agent-messenger 2.7.0 → 2.9.0

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

@@ -2,9 +2,20 @@ import { beforeEach, describe, expect, mock, test } from 'bun:test'
 
 const mockGetChannel = mock(() => Promise.resolve({ id: 'ws-1', name: 'Workspace One' }))
 const mockListManagers = mock(() =>
-  Promise.resolve([{ id: 'mgr-1', channelId: 'ws-1', accountId: 'acct-1', name: 'Alice', email: 'alice@example.com', roleId: 'role-1' }]),
+  Promise.resolve([
+    {
+      id: 'mgr-1',
+      channelId: 'ws-1',
+      accountId: 'acct-1',
+      name: 'Alice',
+      email: 'alice@example.com',
+      roleId: 'role-1',
+    },
+  ]),
+)
+const mockListBots = mock(() =>
+  Promise.resolve([{ id: 'bot-1', channelId: 'ws-1', name: 'Support Bot', avatarUrl: 'https://example.com/bot.png' }]),
 )
-const mockListBots = mock(() => Promise.resolve([{ id: 'bot-1', channelId: 'ws-1', name: 'Support Bot', avatarUrl: 'https://example.com/bot.png' }]))
 const mockListGroups = mock(() =>
   Promise.resolve([
     { id: 'grp-1', channelId: 'ws-1', name: 'Support' },
@@ -34,9 +45,13 @@ const mockListUserChats = mock((_: string, params?: { state?: string; limit?: nu
         { id: 'chat-2', channelId: 'ws-1', state: 'opened', assigneeId: 'mgr-2', createdAt: 110, updatedAt: 210 },
       ])
     case 'snoozed':
-      return Promise.resolve([{ id: 'chat-3', channelId: 'ws-1', state: 'snoozed', assigneeId: 'mgr-1', createdAt: 120, updatedAt: 220 }])
+      return Promise.resolve([
+        { id: 'chat-3', channelId: 'ws-1', state: 'snoozed', assigneeId: 'mgr-1', createdAt: 120, updatedAt: 220 },
+      ])
     case 'closed':
-      return Promise.resolve([{ id: 'chat-4', channelId: 'ws-1', state: 'closed', assigneeId: 'mgr-2', createdAt: 130, updatedAt: 230 }])
+      return Promise.resolve([
+        { id: 'chat-4', channelId: 'ws-1', state: 'closed', assigneeId: 'mgr-2', createdAt: 130, updatedAt: 230 },
+      ])
     default:
       return Promise.resolve([])
   }
@@ -66,9 +81,54 @@ describe('snapshot command', () => {
     mockListUserChats.mockClear()
   })
 
-  test('returns workspace, managers, bots, groups, and user chats', async () => {
+  test('brief snapshot returns workspace, groups (name only), chat counts, and hint', async () => {
     const result = await snapshotAction()
 
+    expect(result.error).toBeUndefined()
+    expect(result.workspace).toEqual({ id: 'ws-1', name: 'Workspace One' })
+    expect(result.groups).toEqual([
+      { id: 'grp-1', name: 'Support' },
+      { id: 'grp-2', name: 'Sales' },
+    ])
+    expect(result.user_chats).toEqual({
+      total: 4,
+      by_state: { opened: 2, snoozed: 1, closed: 1 },
+    })
+    expect(result.hint).toBeDefined()
+    expect(result.managers).toBeUndefined()
+    expect(result.bots).toBeUndefined()
+    expect(mockGetGroupMessages).not.toHaveBeenCalled()
+  })
+
+  test('brief groups-only returns group names without messages', async () => {
+    const result = await snapshotAction({ groupsOnly: true })
+
+    expect(result.workspace).toEqual({ id: 'ws-1', name: 'Workspace One' })
+    expect(result.groups).toHaveLength(2)
+    expect(result.groups?.[0]).toEqual({ id: 'grp-1', name: 'Support' })
+    expect(result.hint).toBeDefined()
+    expect(result.user_chats).toBeUndefined()
+    expect(mockGetGroupMessages).not.toHaveBeenCalled()
+    expect(mockListUserChats).not.toHaveBeenCalled()
+  })
+
+  test('brief chats-only returns counts without recent details', async () => {
+    const result = await snapshotAction({ chatsOnly: true })
+
+    expect(result.workspace).toEqual({ id: 'ws-1', name: 'Workspace One' })
+    expect(result.groups).toBeUndefined()
+    expect(result.user_chats).toEqual({
+      total: 4,
+      by_state: { opened: 2, snoozed: 1, closed: 1 },
+    })
+    expect(result.hint).toBeDefined()
+    expect(mockListGroups).not.toHaveBeenCalled()
+    expect(mockGetGroupMessages).not.toHaveBeenCalled()
+  })
+
+  test('full snapshot returns workspace, managers, bots, groups, and user chats', async () => {
+    const result = await snapshotAction({ full: true })
+
     expect(result.error).toBeUndefined()
     expect(result).toEqual({
       workspace: { id: 'ws-1', name: 'Workspace One' },
@@ -141,19 +201,21 @@ describe('snapshot command', () => {
     })
   })
 
-  test('groups-only skips user chats', async () => {
-    const result = await snapshotAction({ groupsOnly: true })
+  test('full groups-only includes messages', async () => {
+    const result = await snapshotAction({ full: true, groupsOnly: true, limit: 3 })
 
-    expect(result.workspace).toEqual({ id: 'ws-1', name: 'Workspace One' })
-    expect(result.groups).toHaveLength(2)
-    expect(result.user_chats).toBeUndefined()
-    expect(result.managers).toBeUndefined()
-    expect(result.bots).toBeUndefined()
-    expect(mockListUserChats).not.toHaveBeenCalled()
+    expect(mockGetGroupMessages).toHaveBeenCalledWith('ws-1', 'grp-1', { limit: 3, sortOrder: 'desc' })
+    expect(mockGetGroupMessages).toHaveBeenCalledWith('ws-1', 'grp-2', { limit: 3, sortOrder: 'desc' })
+    expect(result.groups?.[0].recent_messages?.[0]).toEqual({
+      id: 'grp-1-msg-1',
+      person_type: 'manager',
+      plain_text: 'Message for grp-1',
+      created_at: 1000,
+    })
   })
 
-  test('chats-only skips groups', async () => {
-    const result = await snapshotAction({ chatsOnly: true, limit: 1 })
+  test('full chats-only includes recent details', async () => {
+    const result = await snapshotAction({ full: true, chatsOnly: true, limit: 1 })
 
     expect(result.workspace).toEqual({ id: 'ws-1', name: 'Workspace One' })
     expect(result.groups).toBeUndefined()
@@ -174,20 +236,5 @@ describe('snapshot command', () => {
         },
       ],
     })
-    expect(mockListGroups).not.toHaveBeenCalled()
-    expect(mockGetGroupMessages).not.toHaveBeenCalled()
-  })
-
-  test('includes recent messages for each group with requested limit', async () => {
-    const result = await snapshotAction({ groupsOnly: true, limit: 3 })
-
-    expect(mockGetGroupMessages).toHaveBeenCalledWith('ws-1', 'grp-1', { limit: 3, sortOrder: 'desc' })
-    expect(mockGetGroupMessages).toHaveBeenCalledWith('ws-1', 'grp-2', { limit: 3, sortOrder: 'desc' })
-    expect(result.groups?.[0].recent_messages[0]).toEqual({
-      id: 'grp-1-msg-1',
-      person_type: 'manager',
-      plain_text: 'Message for grp-1',
-      created_at: 1000,
-    })
   })
 })

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

@@ -10,6 +10,7 @@ interface SnapshotOptions {
   pretty?: boolean
   groupsOnly?: boolean
   chatsOnly?: boolean
+  full?: boolean
   limit?: number | string
 }
 
@@ -33,7 +34,7 @@ interface SnapshotResult {
   groups?: Array<{
     id: string
     name: string
-    recent_messages: Array<{
+    recent_messages?: Array<{
       id: string
       person_type?: string
       plain_text?: string
@@ -43,7 +44,7 @@ interface SnapshotResult {
   user_chats?: {
     total: number
     by_state: Record<string, number>
-    recent: Array<{
+    recent?: Array<{
       id: string
       state?: string
       assignee_id?: string
@@ -51,6 +52,7 @@ interface SnapshotResult {
       updated_at?: number
     }>
   }
+  hint?: string
   error?: string
 }
 
@@ -58,7 +60,6 @@ export async function snapshotAction(options: SnapshotOptions = {}): Promise<Sna
   try {
     const client = await getClient(options)
     const workspaceId = await getCurrentWorkspaceId(options)
-    const limit = parseLimit(options.limit)
 
     const channel = await client.getChannel(workspaceId)
     const workspace = {
@@ -66,42 +67,114 @@ export async function snapshotAction(options: SnapshotOptions = {}): Promise<Sna
       name: channel.name,
     }
 
-    if (options.groupsOnly) {
-      const groups = await buildGroupsSnapshot(client, workspaceId, limit)
-      return { workspace, groups }
+    if (options.full) {
+      return buildFullSnapshot(client, workspaceId, workspace, options)
     }
 
-    if (options.chatsOnly) {
-      const userChats = await buildUserChatsSnapshot(client, workspaceId, limit)
-      return { workspace, user_chats: userChats }
+    return buildBriefSnapshot(client, workspaceId, workspace, options)
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+async function buildBriefSnapshot(
+  client: Awaited<ReturnType<typeof getClient>>,
+  workspaceId: string,
+  workspace: { id: string; name: string },
+  options: SnapshotOptions,
+): Promise<SnapshotResult> {
+  if (options.groupsOnly) {
+    const groups = await client.listGroups(workspaceId, { limit: 20 })
+    return {
+      workspace,
+      groups: groups.map((g) => ({ id: g.id, name: g.name })),
+      hint: "Use 'group messages <group>' for messages.",
     }
+  }
 
-    const [managers, bots, groups, userChats] = await Promise.all([
-      client.listManagers(workspaceId, { limit: 50 }),
-      client.listBots(workspaceId, { limit: 50 }),
-      buildGroupsSnapshot(client, workspaceId, limit),
-      buildUserChatsSnapshot(client, workspaceId, limit),
+  if (options.chatsOnly) {
+    const [openedChats, snoozedChats, closedChats] = await Promise.all([
+      client.listUserChats(workspaceId, { state: 'opened', limit: 100 }),
+      client.listUserChats(workspaceId, { state: 'snoozed', limit: 100 }),
+      client.listUserChats(workspaceId, { state: 'closed', limit: 100 }),
     ])
-
     return {
       workspace,
-      managers: managers.map((manager) => ({
-        id: manager.id,
-        name: manager.name,
-        email: manager.email,
-        account_id: manager.accountId,
-        role_id: manager.roleId,
-      })),
-      bots: bots.map((bot) => ({
-        id: bot.id,
-        name: bot.name,
-        avatar_url: bot.avatarUrl,
-      })),
-      groups,
-      user_chats: userChats,
+      user_chats: {
+        total: openedChats.length + snoozedChats.length + closedChats.length,
+        by_state: {
+          opened: openedChats.length,
+          snoozed: snoozedChats.length,
+          closed: closedChats.length,
+        },
+      },
+      hint: "Use 'chat list --state opened' for chat details, 'chat messages <chat>' for messages.",
     }
-  } catch (error) {
-    return { error: (error as Error).message }
+  }
+
+  const [groups, openedChats, snoozedChats, closedChats] = await Promise.all([
+    client.listGroups(workspaceId, { limit: 20 }),
+    client.listUserChats(workspaceId, { state: 'opened', limit: 100 }),
+    client.listUserChats(workspaceId, { state: 'snoozed', limit: 100 }),
+    client.listUserChats(workspaceId, { state: 'closed', limit: 100 }),
+  ])
+
+  return {
+    workspace,
+    groups: groups.map((g) => ({ id: g.id, name: g.name })),
+    user_chats: {
+      total: openedChats.length + snoozedChats.length + closedChats.length,
+      by_state: {
+        opened: openedChats.length,
+        snoozed: snoozedChats.length,
+        closed: 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>>,
+  workspaceId: string,
+  workspace: { id: string; name: string },
+  options: SnapshotOptions,
+): Promise<SnapshotResult> {
+  const limit = parseLimit(options.limit)
+
+  if (options.groupsOnly) {
+    const groups = await buildGroupsSnapshot(client, workspaceId, limit)
+    return { workspace, groups }
+  }
+
+  if (options.chatsOnly) {
+    const userChats = await buildUserChatsSnapshot(client, workspaceId, limit)
+    return { workspace, user_chats: userChats }
+  }
+
+  const [managers, bots, groups, userChats] = await Promise.all([
+    client.listManagers(workspaceId, { limit: 50 }),
+    client.listBots(workspaceId, { limit: 50 }),
+    buildGroupsSnapshot(client, workspaceId, limit),
+    buildUserChatsSnapshot(client, workspaceId, limit),
+  ])
+
+  return {
+    workspace,
+    managers: managers.map((manager) => ({
+      id: manager.id,
+      name: manager.name,
+      email: manager.email,
+      account_id: manager.accountId,
+      role_id: manager.roleId,
+    })),
+    bots: bots.map((bot) => ({
+      id: bot.id,
+      name: bot.name,
+      avatar_url: bot.avatarUrl,
+    })),
+    groups,
+    user_chats: userChats,
   }
 }
 
@@ -141,7 +214,11 @@ async function buildGroupsSnapshot(client: Awaited<ReturnType<typeof getClient>>
   )
 }
 
-async function buildUserChatsSnapshot(client: Awaited<ReturnType<typeof getClient>>, workspaceId: string, limit: number) {
+async function buildUserChatsSnapshot(
+  client: Awaited<ReturnType<typeof getClient>>,
+  workspaceId: string,
+  limit: number,
+) {
   const [openedChats, snoozedChats, closedChats] = await Promise.all([
     client.listUserChats(workspaceId, { state: 'opened', limit: 100 }),
     client.listUserChats(workspaceId, { state: 'snoozed', limit: 100 }),
@@ -174,10 +251,11 @@ function cliOutput(result: SnapshotResult, pretty?: boolean): void {
 
 export function createSnapshotCommand(): Command {
   return 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 and recent opened chats', '5')
+    .option('--limit <n>', 'Messages per group and recent opened chats with --full', '5')
     .option('--workspace <id>', 'Workspace ID')
     .option('--pretty', 'Pretty print JSON output')
     .action(async (options: SnapshotOptions) => {

package/src/platforms/channeltalk/ensure-auth.test.ts

@@ -6,15 +6,14 @@ import {
   setEnsureChannelAuthDependenciesForTesting,
 } from './ensure-auth'
 
-const mockGetCredentials = mock<() => Promise<
-  | {
-      workspace_id: string
-      workspace_name: string
-      account_cookie: string
-      session_cookie: string
-    }
-  | null
->>(() => Promise.resolve(null))
+const mockGetCredentials = mock<
+  () => Promise<{
+    workspace_id: string
+    workspace_name: string
+    account_cookie: string
+    session_cookie: string
+  } | null>
+>(() => Promise.resolve(null))
 const mockSetCredentials = mock(() => Promise.resolve())
 const mockSetCurrent = mock(() => Promise.resolve(true))
 const mockExtract = mock(() => Promise.resolve([]))
@@ -65,10 +64,12 @@ describe('ensureChannelAuth', () => {
 
   test('extracts and saves workspaces when no credentials exist', async () => {
     mockExtract.mockImplementation(() =>
-      Promise.resolve([{
-        accountCookie: 'account-cookie',
-        sessionCookie: 'session-cookie',
-      }]),
+      Promise.resolve([
+        {
+          accountCookie: 'account-cookie',
+          sessionCookie: 'session-cookie',
+        },
+      ]),
     )
     mockListChannels.mockImplementation(() =>
       Promise.resolve([
@@ -128,10 +129,12 @@ describe('ensureChannelAuth', () => {
     )
     mockGetAccount.mockImplementationOnce(() => Promise.reject(new Error('Unauthorized')))
     mockExtract.mockImplementation(() =>
-      Promise.resolve([{
-        accountCookie: 'fresh-account',
-        sessionCookie: 'fresh-session',
-      }]),
+      Promise.resolve([
+        {
+          accountCookie: 'fresh-account',
+          sessionCookie: 'fresh-session',
+        },
+      ]),
     )
 
     await ensureChannelAuth()

package/src/platforms/channeltalk/ensure-auth.ts

@@ -3,13 +3,13 @@ import { ChannelCredentialManager } from './credential-manager'
 import { ChannelTokenExtractor } from './token-extractor'
 
 type ChannelClientLike = Pick<ChannelClient, 'getAccount' | 'listChannels'>
-type ChannelCredentialManagerLike = Pick<
-  ChannelCredentialManager,
-  'getCredentials' | 'setCredentials' | 'setCurrent'
->
+type ChannelCredentialManagerLike = Pick<ChannelCredentialManager, 'getCredentials' | 'setCredentials' | 'setCurrent'>
 type ChannelTokenExtractorLike = Pick<ChannelTokenExtractor, 'extract'>
 
-let createChannelClient: (accountCookie: string, sessionCookie?: string) => ChannelClientLike | Promise<ChannelClientLike> = async (
+let createChannelClient: (
+  accountCookie: string,
+  sessionCookie?: string,
+) => ChannelClientLike | Promise<ChannelClientLike> = async (
   accountCookie: string,
   sessionCookie?: string,
 ): Promise<ChannelClientLike> => new ChannelClient().login({ accountCookie, sessionCookie })
@@ -38,8 +38,7 @@ export const setEnsureChannelAuthClientFactoryForTesting = (
   factory: (accountCookie: string, sessionCookie?: string) => ChannelClientLike | Promise<ChannelClientLike>,
 ): void => setEnsureChannelAuthDependenciesForTesting({ createClient: factory })
 
-export const resetEnsureChannelAuthClientFactoryForTesting = (): void =>
-  resetEnsureChannelAuthDependenciesForTesting()
+export const resetEnsureChannelAuthClientFactoryForTesting = (): void => resetEnsureChannelAuthDependenciesForTesting()
 
 export async function ensureChannelAuth(): Promise<void> {
   try {

package/src/platforms/channeltalk/index.ts

@@ -44,4 +44,3 @@ export {
   ExtractedChannelTokenSchema,
   MessageBlockSchema,
 } from './types'
-

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

@@ -62,13 +62,7 @@ describe('ChannelTokenExtractor', () => {
       const extractor = new ChannelTokenExtractor('darwin')
       const paths = extractor.getBrowserCookiesPaths()
 
-      const chromeBase = join(
-        process.env.HOME || '/tmp',
-        'Library',
-        'Application Support',
-        'Google',
-        'Chrome',
-      )
+      const chromeBase = join(process.env.HOME || '/tmp', 'Library', 'Application Support', 'Google', 'Chrome')
       expect(paths).toContain(join(chromeBase, 'Default', 'Cookies'))
       expect(paths).toContain(join(chromeBase, 'Default', 'Network', 'Cookies'))
     })
@@ -132,10 +126,12 @@ describe('ChannelTokenExtractor', () => {
       const extractor = new ChannelTokenExtractor('darwin')
 
       const desktopSpy = spyOn(extractor as any, 'extractFromDesktopApp').mockResolvedValue(null)
-      const browserSpy = spyOn(extractor as any, 'extractAllFromBrowserPaths').mockResolvedValue([{
-        accountCookie: 'browser-account',
-        sessionCookie: undefined,
-      }])
+      const browserSpy = spyOn(extractor as any, 'extractAllFromBrowserPaths').mockResolvedValue([
+        {
+          accountCookie: 'browser-account',
+          sessionCookie: undefined,
+        },
+      ])
 
       const result = await extractor.extract()
 
@@ -169,10 +165,12 @@ describe('ChannelTokenExtractor', () => {
 
       const extractor = new TestExtractor(dbPath)
 
-      expect(await extractor.extract()).toEqual([{
-        accountCookie: 'account-jwt',
-        sessionCookie: 'session-jwt',
-      }])
+      expect(await extractor.extract()).toEqual([
+        {
+          accountCookie: 'account-jwt',
+          sessionCookie: 'session-jwt',
+        },
+      ])
     })
 
     test('returns token with undefined sessionCookie when only x-account is present', async () => {
@@ -265,7 +263,10 @@ describe('ChannelTokenExtractor', () => {
 
       const localStatePath = join(tempDir, 'Local State')
       const fakeEncryptedKey = Buffer.concat([Buffer.from('DPAPI'), randomBytes(32)])
-      writeFileSync(localStatePath, JSON.stringify({ os_crypt: { encrypted_key: fakeEncryptedKey.toString('base64') } }))
+      writeFileSync(
+        localStatePath,
+        JSON.stringify({ os_crypt: { encrypted_key: fakeEncryptedKey.toString('base64') } }),
+      )
 
       const extractor = new TestWinExtractor(dbPath, masterKey)
       const result = await extractor.extract()
@@ -283,10 +284,12 @@ describe('ChannelTokenExtractor', () => {
         accountCookie: 'same-account-cookie',
         sessionCookie: 'desktop-session',
       })
-      const browserSpy = spyOn(extractor as any, 'extractAllFromBrowserPaths').mockResolvedValue([{
-        accountCookie: 'same-account-cookie',
-        sessionCookie: 'browser-session',
-      }])
+      const browserSpy = spyOn(extractor as any, 'extractAllFromBrowserPaths').mockResolvedValue([
+        {
+          accountCookie: 'same-account-cookie',
+          sessionCookie: 'browser-session',
+        },
+      ])
 
       const result = await extractor.extract()
       expect(result).toHaveLength(1)
@@ -303,10 +306,12 @@ describe('ChannelTokenExtractor', () => {
         accountCookie: 'desktop-account-cookie',
         sessionCookie: 'desktop-session',
       })
-      const browserSpy = spyOn(extractor as any, 'extractAllFromBrowserPaths').mockResolvedValue([{
-        accountCookie: 'browser-account-cookie',
-        sessionCookie: 'browser-session',
-      }])
+      const browserSpy = spyOn(extractor as any, 'extractAllFromBrowserPaths').mockResolvedValue([
+        {
+          accountCookie: 'browser-account-cookie',
+          sessionCookie: 'browser-session',
+        },
+      ])
 
       const result = await extractor.extract()
       expect(result).toHaveLength(2)
@@ -350,7 +355,10 @@ describe('ChannelTokenExtractor', () => {
 
       const localStatePath = join(tempDir, 'Local State')
       const fakeEncryptedKey = Buffer.concat([Buffer.from('DPAPI'), randomBytes(32)])
-      writeFileSync(localStatePath, JSON.stringify({ os_crypt: { encrypted_key: fakeEncryptedKey.toString('base64') } }))
+      writeFileSync(
+        localStatePath,
+        JSON.stringify({ os_crypt: { encrypted_key: fakeEncryptedKey.toString('base64') } }),
+      )
 
       const extractor = new FailingDPAPIExtractor(dbPath)
       const result = await extractor.extract()