agent-messenger 1.14.0 → 2.0.0

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

@@ -0,0 +1,242 @@
+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'
+
+async function getClient(pretty?: boolean): Promise<SlackClient | null> {
+  const credManager = new CredentialManager()
+  const ws = await credManager.getWorkspace()
+
+  if (!ws) {
+    console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, pretty))
+    return null
+  }
+
+  return await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
+}
+
+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)
+
+    const usergroups = await client.listUsergroups({
+      includeDisabled: options.includeDisabled,
+      includeUsers: options.includeUsers,
+      includeCount: true,
+    })
+
+    const output = usergroups.map((ug) => ({
+      id: ug.id,
+      name: ug.name,
+      handle: ug.handle,
+      description: ug.description,
+      user_count: ug.user_count,
+      date_create: ug.date_create,
+      date_update: ug.date_update,
+      ...(options.includeDisabled && { date_delete: ug.date_delete }),
+      ...(options.includeUsers && { users: ug.users }),
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function createAction(
+  name: string,
+  options: { handle?: string; description?: string; channels?: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const client = await getClient(options.pretty)
+    if (!client) return process.exit(1)
+
+    const channels = options.channels?.split(',').map((c) => c.trim())
+    const usergroup = await client.createUsergroup(name, {
+      handle: options.handle,
+      description: options.description,
+      channels,
+    })
+
+    console.log(
+      formatOutput(
+        {
+          id: usergroup.id,
+          name: usergroup.name,
+          handle: usergroup.handle,
+          description: usergroup.description,
+        },
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function updateAction(
+  usergroupId: string,
+  options: { name?: string; handle?: string; description?: string; channels?: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const client = await getClient(options.pretty)
+    if (!client) return process.exit(1)
+
+    const channels = options.channels?.split(',').map((c) => c.trim())
+    const usergroup = await client.updateUsergroup(usergroupId, {
+      name: options.name,
+      handle: options.handle,
+      description: options.description,
+      channels,
+    })
+
+    console.log(
+      formatOutput(
+        {
+          id: usergroup.id,
+          name: usergroup.name,
+          handle: usergroup.handle,
+          description: usergroup.description,
+        },
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function enableAction(usergroupId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const client = await getClient(options.pretty)
+    if (!client) return process.exit(1)
+
+    const usergroup = await client.enableUsergroup(usergroupId)
+
+    console.log(formatOutput({ success: true, id: usergroup.id, name: usergroup.name }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function disableAction(usergroupId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const client = await getClient(options.pretty)
+    if (!client) return process.exit(1)
+
+    const usergroup = await client.disableUsergroup(usergroupId)
+
+    console.log(formatOutput({ success: true, id: usergroup.id, name: usergroup.name }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+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)
+
+    const users = await client.listUsergroupMembers(usergroupId, {
+      includeDisabled: options.includeDisabled,
+    })
+
+    console.log(formatOutput(users, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+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)
+
+    const userIds = users.split(',').map((u) => u.trim())
+    const usergroup = await client.updateUsergroupMembers(usergroupId, userIds)
+
+    console.log(
+      formatOutput(
+        {
+          id: usergroup.id,
+          name: usergroup.name,
+          users: usergroup.users,
+          user_count: usergroup.user_count,
+        },
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const usergroupCommand = new Command('usergroup')
+  .description('User group commands')
+  .addCommand(
+    new Command('list')
+      .description('List user groups')
+      .option('--include-disabled', 'Include disabled user groups')
+      .option('--include-users', 'Include member list per group')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('create')
+      .description('Create a user group')
+      .argument('<name>', 'User group name')
+      .option('--handle <handle>', 'Mention handle (must be unique)')
+      .option('--description <description>', 'Short description')
+      .option('--channels <channels>', 'Comma-separated default channel IDs')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(createAction),
+  )
+  .addCommand(
+    new Command('update')
+      .description('Update a user group')
+      .argument('<usergroup-id>', 'User group ID')
+      .option('--name <name>', 'New name')
+      .option('--handle <handle>', 'New mention handle')
+      .option('--description <description>', 'New description')
+      .option('--channels <channels>', 'Comma-separated default channel IDs')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(updateAction),
+  )
+  .addCommand(
+    new Command('enable')
+      .description('Enable a disabled user group')
+      .argument('<usergroup-id>', 'User group ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(enableAction),
+  )
+  .addCommand(
+    new Command('disable')
+      .description('Disable a user group')
+      .argument('<usergroup-id>', 'User group ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(disableAction),
+  )
+  .addCommand(
+    new Command('members')
+      .description('List members of a user group')
+      .argument('<usergroup-id>', 'User group ID')
+      .option('--include-disabled', 'Include members from disabled groups')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(membersAction),
+  )
+  .addCommand(
+    new Command('members-update')
+      .description('Update the member list of a user group (replaces all members)')
+      .argument('<usergroup-id>', 'User group ID')
+      .argument('<users>', 'Comma-separated user IDs')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(membersUpdateAction),
+  )

package/src/platforms/slack/credential-manager.ts

@@ -5,7 +5,7 @@ import { join } from 'node:path'
 
 import type { Config, WorkspaceCredentials } from './types'
 
-export class CredentialManager {
+export class SlackCredentialManager {
   private configDir: string
   private credentialsPath: string
 
@@ -88,3 +88,5 @@ export class CredentialManager {
     await this.save(config)
   }
 }
+
+export { SlackCredentialManager as CredentialManager }

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

@@ -8,7 +8,7 @@ export async function ensureSlackAuth(): Promise<void> {
 
   if (workspace) {
     try {
-      const client = new SlackClient(workspace.token, workspace.cookie)
+      const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
       await client.testAuth()
       return
     } catch {
@@ -24,7 +24,7 @@ export async function ensureSlackAuth(): Promise<void> {
     const validWorkspaces = []
     for (const ws of workspaces) {
       try {
-        const client = new SlackClient(ws.token, ws.cookie)
+        const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
         const authInfo = await client.testAuth()
         ws.workspace_id = authInfo.team_id
         ws.workspace_name = authInfo.team || ws.workspace_name
@@ -66,7 +66,7 @@ export async function tryWebTokenRefresh(
     const freshToken = await refreshTokenFromWeb(domain, ws.cookie)
     if (!freshToken) return null
 
-    const client = new SlackClient(freshToken, ws.cookie)
+    const client = await new SlackClient().login({ token: freshToken, cookie: ws.cookie })
     const authInfo = await client.testAuth()
     return { token: freshToken, workspace_name: authInfo.team || ws.workspace_name }
   } catch {
@@ -101,7 +101,7 @@ export async function refreshCookie(
     const freshCookie = await extractor.extractCookie()
     if (!freshCookie) return null
 
-    const client = new SlackClient(token, freshCookie)
+    const client = await new SlackClient().login({ token: token, cookie: freshCookie })
     const authInfo = await client.testAuth()
 
     const config = await credManager.load()

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

@@ -0,0 +1,59 @@
+import { expect, test } from 'bun:test'
+
+import {
+  CredentialManager,
+  SlackCredentialManager,
+  SlackChannelSchema,
+  SlackClient,
+  SlackError,
+  SlackFileSchema,
+  SlackMessageSchema,
+  SlackReactionSchema,
+  SlackUserSchema,
+  WorkspaceCredentialsSchema,
+  ConfigSchema,
+} from '@/platforms/slack/index'
+
+test('SlackClient is exported from barrel', () => {
+  expect(typeof SlackClient).toBe('function')
+})
+
+test('SlackError is exported from barrel', () => {
+  expect(typeof SlackError).toBe('function')
+})
+
+test('CredentialManager is exported from barrel', () => {
+  expect(typeof CredentialManager).toBe('function')
+})
+
+test('SlackCredentialManager is exported from barrel', () => {
+  expect(typeof SlackCredentialManager).toBe('function')
+})
+
+test('SlackChannelSchema is exported from barrel', () => {
+  expect(typeof SlackChannelSchema.parse).toBe('function')
+})
+
+test('SlackReactionSchema is exported from barrel', () => {
+  expect(typeof SlackReactionSchema.parse).toBe('function')
+})
+
+test('SlackFileSchema is exported from barrel', () => {
+  expect(typeof SlackFileSchema.parse).toBe('function')
+})
+
+test('SlackMessageSchema is exported from barrel', () => {
+  expect(typeof SlackMessageSchema.parse).toBe('function')
+})
+
+test('SlackUserSchema is exported from barrel', () => {
+  expect(typeof SlackUserSchema.parse).toBe('function')
+})
+
+test('WorkspaceCredentialsSchema is exported from barrel', () => {
+  expect(typeof WorkspaceCredentialsSchema.parse).toBe('function')
+})
+
+test('ConfigSchema is exported from barrel', () => {
+  expect(typeof ConfigSchema.parse).toBe('function')
+})

package/src/platforms/slack/index.ts

@@ -1,2 +1,47 @@
 export { SlackClient, SlackError } from './client'
-export { CredentialManager } from './credential-manager'
+export { SlackCredentialManager, CredentialManager } from './credential-manager'
+export { SlackListener } from './listener'
+export type {
+  SlackBookmark,
+  SlackChannel,
+  SlackMessage,
+  SlackPin,
+  SlackReminder,
+  SlackScheduledMessage,
+  SlackUser,
+  SlackUserProfile,
+  SlackUsergroup,
+  SlackReaction,
+  SlackFile,
+  SlackSearchResult,
+  SlackUnreadCounts,
+  SlackThreadView,
+  SlackSavedItem,
+  SlackActivityItem,
+  SlackDM,
+  SlackDraft,
+  SlackChannelSection,
+  SlackRTMEvent,
+  SlackRTMMessageEvent,
+  SlackRTMReactionEvent,
+  SlackRTMMemberEvent,
+  SlackRTMChannelEvent,
+  SlackRTMPresenceEvent,
+  SlackRTMUserTypingEvent,
+  SlackRTMGenericEvent,
+  SlackListenerEventMap,
+  WorkspaceCredentials,
+  Config,
+} from './types'
+export {
+  SlackChannelSchema,
+  SlackReactionSchema,
+  SlackFileSchema,
+  SlackMessageSchema,
+  SlackUserSchema,
+  SlackUsergroupSchema,
+  WorkspaceCredentialsSchema,
+  ConfigSchema,
+} from './types'
+
+