agent-messenger 2.7.0 → 2.8.0

package/src/platforms/channeltalk/client.ts

@@ -1,3 +1,4 @@
+import { ChannelCredentialManager } from './credential-manager'
 import type {
   Channel,
   ChannelAccount,
@@ -11,7 +12,6 @@ import type {
   MessageBlock,
 } from './types'
 import { ChannelError } from './types'
-import { ChannelCredentialManager } from './credential-manager'
 
 const BASE_URL = 'https://desk-api.channel.io'
 const MAX_RETRIES = 3
@@ -99,11 +99,21 @@ export class ChannelClient {
   }
 
   async getManagerRole(channelId: string): Promise<{ permissions: unknown[] }> {
-    return this.request<{ permissions: unknown[] }>('GET', `/desk/channels/${channelId}/managers/me/role`, undefined, 'role')
+    return this.request<{ permissions: unknown[] }>(
+      'GET',
+      `/desk/channels/${channelId}/managers/me/role`,
+      undefined,
+      'role',
+    )
   }
 
   async listGroups(channelId: string, params?: { limit?: number }): Promise<ChannelGroup[]> {
-    return this.request<ChannelGroup[]>('GET', this.buildPath(`/desk/channels/${channelId}/groups`, params), undefined, 'groups')
+    return this.request<ChannelGroup[]>(
+      'GET',
+      this.buildPath(`/desk/channels/${channelId}/groups`, params),
+      undefined,
+      'groups',
+    )
   }
 
   async getGroup(channelId: string, groupId: string): Promise<ChannelGroup> {
@@ -183,7 +193,12 @@ export class ChannelClient {
   }
 
   async getUserChat(channelId: string, chatId: string): Promise<ChannelUserChat> {
-    return this.request<ChannelUserChat>('GET', `/desk/channels/${channelId}/user-chats/${chatId}`, undefined, 'userChat')
+    return this.request<ChannelUserChat>(
+      'GET',
+      `/desk/channels/${channelId}/user-chats/${chatId}`,
+      undefined,
+      'userChat',
+    )
   }
 
   async getUserChatMessages(
@@ -214,7 +229,12 @@ export class ChannelClient {
   }
 
   async listBots(channelId: string, params?: { limit?: number }): Promise<ChannelBot[]> {
-    return this.request<ChannelBot[]>('GET', this.buildPath(`/desk/channels/${channelId}/bots`, params), undefined, 'bots')
+    return this.request<ChannelBot[]>(
+      'GET',
+      this.buildPath(`/desk/channels/${channelId}/bots`, params),
+      undefined,
+      'bots',
+    )
   }
 
   async searchTeamChatMessages(
@@ -344,7 +364,7 @@ export class ChannelClient {
   }
 
   private async createHttpError(response: Response): Promise<ChannelError> {
-    const errorBody = await response.json().catch(() => ({})) as ChannelApiErrorResponse
+    const errorBody = (await response.json().catch(() => ({}))) as ChannelApiErrorResponse
     const message = errorBody.errors?.[0]?.message || `HTTP ${response.status}`
     const code = errorBody.type || `http_${response.status}`
     return new ChannelError(message, code)

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

@@ -19,9 +19,7 @@ const mockListChannels = mock(() =>
     { id: 'ws-2', name: 'Workspace 2' },
   ]),
 )
-const mockExtract = mock(() =>
-  Promise.resolve([{ accountCookie: 'fresh-account', sessionCookie: 'fresh-session' }]),
-)
+const mockExtract = mock(() => Promise.resolve([{ accountCookie: 'fresh-account', sessionCookie: 'fresh-session' }]))
 
 import {
   clearAction,
@@ -50,7 +48,7 @@ setChannelAuthCommandDependenciesForTesting({
   createCredentialManager: () => ({
     async getCredentials(workspaceId?: string): Promise<WorkspaceEntry | null> {
       const targetId = workspaceId ?? currentWorkspaceId
-      return targetId ? workspaceStore.get(targetId) ?? null : null
+      return targetId ? (workspaceStore.get(targetId) ?? null) : null
     },
 
     async setCredentials(entry: WorkspaceEntry): Promise<void> {
@@ -115,7 +113,9 @@ describe('channel auth commands', () => {
         { id: 'ws-2', name: 'Workspace 2' },
       ]),
     )
-    mockExtract.mockImplementation(() => Promise.resolve([{ accountCookie: 'fresh-account', sessionCookie: 'fresh-session' }]))
+    mockExtract.mockImplementation(() =>
+      Promise.resolve([{ accountCookie: 'fresh-account', sessionCookie: 'fresh-session' }]),
+    )
   })
 
   describe('extractAction', () => {

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

@@ -50,7 +50,10 @@ type ChannelCredentialManagerLike = Pick<
 >
 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 })
@@ -60,7 +63,10 @@ let createCredentialManager = (): ChannelCredentialManagerLike => new ChannelCre
 let createTokenExtractor = (): ChannelTokenExtractorLike => new ChannelTokenExtractor()
 
 export function setChannelAuthCommandDependenciesForTesting(dependencies: {
-  createChannelClient?: (accountCookie: string, sessionCookie?: string) => ChannelClientLike | Promise<ChannelClientLike>
+  createChannelClient?: (
+    accountCookie: string,
+    sessionCookie?: string,
+  ) => ChannelClientLike | Promise<ChannelClientLike>
   createCredentialManager?: () => ChannelCredentialManagerLike
   createTokenExtractor?: () => ChannelTokenExtractorLike
 }): void {
@@ -154,7 +160,9 @@ export async function statusAction(options: ActionOptions = {}): Promise<StatusR
       }
     }
 
-    const storedWorkspace = (await credManager.listAll()).find((workspace) => workspace.workspace_id === creds.workspace_id)
+    const storedWorkspace = (await credManager.listAll()).find(
+      (workspace) => workspace.workspace_id === creds.workspace_id,
+    )
 
     try {
       const client = await createChannelClient(creds.account_cookie, creds.session_cookie ?? undefined)
@@ -205,7 +213,10 @@ export async function listAction(options: ActionOptions = {}): Promise<Workspace
   }
 }
 
-export async function useAction(workspaceId: string, options: ActionOptions = {}): Promise<SuccessResult | ErrorResult> {
+export async function useAction(
+  workspaceId: string,
+  options: ActionOptions = {},
+): Promise<SuccessResult | ErrorResult> {
   try {
     const credManager = options._credManager ?? createCredentialManager()
     const found = await credManager.setCurrent(workspaceId)
@@ -223,7 +234,10 @@ export async function useAction(workspaceId: string, options: ActionOptions = {}
   }
 }
 
-export async function removeAction(workspaceId: string, options: ActionOptions = {}): Promise<SuccessResult | ErrorResult> {
+export async function removeAction(
+  workspaceId: string,
+  options: ActionOptions = {},
+): Promise<SuccessResult | ErrorResult> {
   try {
     const credManager = options._credManager ?? createCredentialManager()
     const removed = await credManager.removeWorkspace(workspaceId)

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

@@ -309,9 +309,7 @@ describe('message commands', () => {
   test('sendAction sends a group message with wrapped blocks', async () => {
     const result = await sendAction('group', 'grp-1', 'Hello group')
 
-    expect(mockSendGroupMessage).toHaveBeenCalledWith('ws-1', 'grp-1', [
-      { type: 'text', value: 'Hello group' },
-    ])
+    expect(mockSendGroupMessage).toHaveBeenCalledWith('ws-1', 'grp-1', [{ type: 'text', value: 'Hello group' }])
     expect(result).toMatchObject({
       id: 'msg-group-1',
       channel_id: 'ws-1',
@@ -324,9 +322,7 @@ describe('message commands', () => {
   test('sendAction sends a user chat message with wrapped blocks', async () => {
     const result = await sendAction('user-chat', 'chat-1', 'Hello user chat')
 
-    expect(mockSendUserChatMessage).toHaveBeenCalledWith('ws-1', 'chat-1', [
-      { type: 'text', value: 'Hello user chat' },
-    ])
+    expect(mockSendUserChatMessage).toHaveBeenCalledWith('ws-1', 'chat-1', [{ type: 'text', value: 'Hello user chat' }])
     expect(result).toMatchObject({
       id: 'msg-user-1',
       channel_id: 'ws-1',

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

@@ -70,7 +70,11 @@ export async function sendAction(
   }
 }
 
-export async function listAction(chatType: ChatType, chatId: string, options: MessageOptions = {}): Promise<MessageResult> {
+export async function listAction(
+  chatType: ChatType,
+  chatId: string,
+  options: MessageOptions = {},
+): Promise<MessageResult> {
   try {
     const client = await getClient(options)
     const channelId = await getCurrentWorkspaceId(options)

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([])
   }

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

@@ -141,7 +141,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 }),

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()