npm - agent-messenger - Versions diffs - 1.14.0 → 2.0.0 - Mend

agent-messenger 1.14.0 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (931) hide show

package/src/platforms/line/commands/auth.ts ADDED Viewed

@@ -0,0 +1,219 @@
+import { execSync } from 'node:child_process'
+import { writeFileSync, unlinkSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { Command } from 'commander'
+import QRCode from 'qrcode'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { LineClient } from '../client'
+import { LineCredentialManager } from '../credential-manager'
+import type { LineDevice } from '../types'
+import { LINE_NEXT_ACTIONS } from '../types'
+function isInteractiveSession(): boolean {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY)
+}
+function getDefaultDevice(): LineDevice {
+  return 'ANDROIDSECONDARY'
+}
+async function openQRInBrowser(url: string): Promise<void> {
+  const svgString = await QRCode.toString(url, { type: 'svg', margin: 2 })
+  const html = `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>LINE QR Login</title>
+<style>body{display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;font-family:-apple-system,system-ui,sans-serif;background:#06C755}
+.card{background:#fff;border-radius:16px;padding:40px;text-align:center;box-shadow:0 4px 24px rgba(0,0,0,.15)}
+h1{margin:0 0 8px;font-size:22px;color:#111}p{margin:0 0 24px;color:#666;font-size:14px}
+svg{width:280px;height:280px}</style></head>
+<body><div class="card"><h1>LINE Login</h1><p>Scan with the LINE mobile app</p>${svgString}</div></body></html>`
+  const htmlPath = join(tmpdir(), `line-qr-${Date.now()}.html`)
+  writeFileSync(htmlPath, html)
+  try {
+    if (process.platform === 'darwin') {
+      execSync(`open "${htmlPath}"`, { stdio: 'ignore' })
+    } else if (process.platform === 'win32') {
+      execSync(`start "" "${htmlPath}"`, { stdio: 'ignore' })
+    } else {
+      execSync(`xdg-open "${htmlPath}"`, { stdio: 'ignore' })
+    }
+  } catch {}
+  setTimeout(() => { try { unlinkSync(htmlPath) } catch {} }, 30_000)
+}
+async function loginAction(options: {
+  email?: string
+  password?: string
+  token?: string
+  device?: string
+  pretty?: boolean
+}): Promise<void> {
+  try {
+    const credManager = new LineCredentialManager()
+    const client = new LineClient(credManager)
+    const device: LineDevice = (options.device as LineDevice | undefined) ?? getDefaultDevice()
+    const interactive = isInteractiveSession()
+    if (options.token) {
+      const now = new Date().toISOString()
+      const tempCredentials = {
+        account_id: 'pending',
+        auth_token: options.token,
+        device,
+        created_at: now,
+        updated_at: now,
+      }
+      await client.login(tempCredentials)
+      const profile = await client.getProfile()
+      const credentials = { ...tempCredentials, account_id: profile.mid, display_name: profile.display_name }
+      await credManager.setAccount(credentials)
+      console.log(formatOutput({
+        authenticated: true,
+        account_id: profile.mid,
+        display_name: profile.display_name,
+        device,
+      }, options.pretty))
+    } else if (options.email && options.password) {
+      const result = await client.loginWithEmail({
+        email: options.email,
+        password: options.password,
+        device,
+        onPincode: (pin) => {
+          if (interactive) {
+            console.error(`\nEnter this PIN in the LINE mobile app: ${pin}\n`)
+          }
+        },
+      })
+      console.log(formatOutput(result, options.pretty))
+    } else {
+      if (!interactive) {
+        console.log(formatOutput(LINE_NEXT_ACTIONS.run_interactive, options.pretty))
+        return
+      }
+      const result = await client.loginWithQR({
+        device,
+        onQRUrl: async (url) => {
+          await openQRInBrowser(url).catch(() => {})
+          try {
+            const qrAscii = await QRCode.toString(url, { type: 'terminal', small: true })
+            console.error('\nScan this QR code with the LINE mobile app:\n')
+            console.error(qrAscii)
+          } catch {
+            console.error(`\nOpen the QR code in the browser window, or scan this URL:\n${url}\n`)
+          }
+        },
+        onPincode: (pin) => {
+          console.error(`\nEnter this PIN in the LINE mobile app: ${pin}\n`)
+        },
+      })
+      console.log(formatOutput(result, options.pretty))
+    }
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+async function statusAction(options: { pretty?: boolean; account?: string }): Promise<void> {
+  try {
+    const credManager = new LineCredentialManager()
+    const account = await credManager.getAccount(options.account)
+    if (!account) {
+      console.log(formatOutput({ error: 'No LINE account configured' }, options.pretty))
+      return
+    }
+    console.log(formatOutput({
+      account_id: account.account_id,
+      device: account.device,
+      display_name: account.display_name,
+      created_at: account.created_at,
+      updated_at: account.updated_at,
+    }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+async function listAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new LineCredentialManager()
+    const accounts = await credManager.listAccounts()
+    console.log(formatOutput(accounts, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+async function useAction(accountId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new LineCredentialManager()
+    await credManager.setCurrentAccount(accountId)
+    console.log(formatOutput({ current_account: accountId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+async function logoutAction(accountId: string | undefined, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new LineCredentialManager()
+    if (accountId) {
+      await credManager.removeAccount(accountId)
+      console.log(formatOutput({ success: true, message: `Removed account ${accountId}` }, options.pretty))
+    } else {
+      await credManager.clearAll()
+      console.log(formatOutput({ success: true, message: 'Logged out' }, options.pretty))
+    }
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+export const authCommand = new Command('auth')
+  .description('LINE authentication commands')
+  .addCommand(
+    new Command('login')
+      .description('Login to LINE via QR code (default), email/password, or auth token')
+      .option('--email <email>', 'Email address for email/password login')
+      .option('--password <password>', 'Password for email login')
+      .option('--token <token>', 'Login with existing auth token directly')
+      .option('--device <type>', 'Device type (default: ANDROIDSECONDARY). Secondary device that coexists with LINE desktop. Use DESKTOPMAC/DESKTOPWIN to replace desktop session.')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(loginAction),
+  )
+  .addCommand(
+    new Command('status')
+      .description('Show authentication status')
+      .option('--account <id>', 'Account ID (optional, defaults to current account)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(statusAction),
+  )
+  .addCommand(
+    new Command('list')
+      .description('List all stored LINE accounts')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('use')
+      .description('Set the active LINE account')
+      .argument('<account-id>', 'Account ID to use as current')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(useAction),
+  )
+  .addCommand(
+    new Command('logout')
+      .description('Remove stored credentials (all accounts if no ID given)')
+      .argument('[account-id]', 'Account ID to remove (omit to clear all)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(logoutAction),
+  )

package/src/platforms/line/commands/chat.ts ADDED Viewed

@@ -0,0 +1,34 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { LineClient } from '../client'
+async function listAction(options: {
+  limit?: string
+  pretty?: boolean
+}): Promise<void> {
+  let client: LineClient | undefined
+  try {
+    client = await new LineClient().login()
+    const parsed = options.limit ? Number.parseInt(options.limit, 10) : 50
+    const limit = Number.isFinite(parsed) && parsed > 0 ? parsed : 50
+    const chats = await client.getChats({ limit })
+    console.log(formatOutput(chats, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  } finally {
+    client?.close()
+  }
+}
+export const chatCommand = new Command('chat')
+  .description('LINE chat commands')
+  .addCommand(
+    new Command('list')
+      .description('List conversations (DMs and groups)')
+      .option('-n, --limit <number>', 'Max conversations to return', '50')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )

package/src/platforms/line/commands/friend.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { LineClient } from '../client'
+async function listAction(options: { pretty?: boolean }): Promise<void> {
+  let client: LineClient | undefined
+  try {
+    client = await new LineClient().login()
+    const friends = await client.getFriends()
+    console.log(formatOutput(friends, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  } finally {
+    client?.close()
+  }
+}
+export const friendCommand = new Command('friend')
+  .description('LINE friend commands')
+  .addCommand(
+    new Command('list')
+      .description('List your LINE friends')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )

package/src/platforms/line/commands/index.ts ADDED Viewed

@@ -0,0 +1,5 @@
+export { authCommand } from './auth'
+export { chatCommand } from './chat'
+export { friendCommand } from './friend'
+export { messageCommand } from './message'
+export { profileCommand } from './profile'

package/src/platforms/line/commands/message.ts ADDED Viewed

@@ -0,0 +1,59 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { LineClient } from '../client'
+async function listAction(
+  chatId: string,
+  options: { count?: string; pretty?: boolean },
+): Promise<void> {
+  let client: LineClient | undefined
+  try {
+    client = await new LineClient().login()
+    const count = options.count ? Number.parseInt(options.count, 10) : 20
+    const messages = await client.getMessages(chatId, { count })
+    console.log(formatOutput(messages, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  } finally {
+    client?.close()
+  }
+}
+async function sendAction(
+  chatId: string,
+  text: string,
+  options: { pretty?: boolean },
+): Promise<void> {
+  let client: LineClient | undefined
+  try {
+    client = await new LineClient().login()
+    const result = await client.sendMessage(chatId, text)
+    console.log(formatOutput(result, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  } finally {
+    client?.close()
+  }
+}
+export const messageCommand = new Command('message')
+  .description('LINE message commands')
+  .addCommand(
+    new Command('list')
+      .description('List messages in a chat room')
+      .argument('<chat-id>', 'Chat room MID')
+      .option('-n, --count <number>', 'Number of messages to fetch', '20')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('send')
+      .description('Send a text message to a chat room')
+      .argument('<chat-id>', 'Chat room MID')
+      .argument('<text>', 'Message text')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(sendAction),
+  )

package/src/platforms/line/commands/profile.ts ADDED Viewed

@@ -0,0 +1,24 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { LineClient } from '../client'
+async function profileAction(options: { pretty?: boolean }): Promise<void> {
+  let client: LineClient | undefined
+  try {
+    client = await new LineClient().login()
+    const profile = await client.getProfile()
+    console.log(formatOutput(profile, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  } finally {
+    client?.close()
+  }
+}
+export const profileCommand = new Command('profile')
+  .description('Show your LINE profile')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(profileAction)

package/src/platforms/line/credential-manager.test.ts ADDED Viewed

@@ -0,0 +1,163 @@
+import { mkdir, rm, stat } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { LineCredentialManager } from './credential-manager'
+import type { LineAccountCredentials } from './types'
+const makeAccount = (id: string): LineAccountCredentials => ({
+  account_id: id,
+  auth_token: `token-${id}`,
+  device: 'DESKTOPMAC',
+  display_name: `User ${id}`,
+  created_at: new Date().toISOString(),
+  updated_at: new Date().toISOString(),
+})
+let tempDir: string
+let manager: LineCredentialManager
+beforeEach(async () => {
+  tempDir = join(tmpdir(), `line-cred-test-${Date.now()}`)
+  await mkdir(tempDir, { recursive: true })
+  manager = new LineCredentialManager(tempDir)
+})
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true })
+})
+describe('LineCredentialManager', () => {
+  test('load returns default config when file does not exist', async () => {
+    const config = await manager.load()
+    expect(config).toEqual({ current_account: null, accounts: {} })
+  })
+  test('save and load round trip', async () => {
+    const account = makeAccount('alice')
+    const config = { current_account: 'alice', accounts: { alice: account } }
+    await manager.save(config)
+    const loaded = await manager.load()
+    expect(loaded).toEqual(config)
+  })
+  test('file is created with 0o600 permissions', async () => {
+    await manager.save({ current_account: null, accounts: {} })
+    const fileStat = await stat(join(tempDir, 'line-credentials.json'))
+    // Check owner read/write only (0o600)
+    expect(fileStat.mode & 0o777).toBe(0o600)
+  })
+  test('setAccount adds account and sets as current if first', async () => {
+    const account = makeAccount('alice')
+    await manager.setAccount(account)
+    const loaded = await manager.load()
+    expect(loaded.accounts['alice']).toEqual(account)
+    expect(loaded.current_account).toBe('alice')
+  })
+  test('setAccount does not change current if already set', async () => {
+    await manager.setAccount(makeAccount('alice'))
+    await manager.setAccount(makeAccount('bob'))
+    const loaded = await manager.load()
+    expect(loaded.current_account).toBe('alice')
+  })
+  test('getAccount returns null when no accounts', async () => {
+    const result = await manager.getAccount()
+    expect(result).toBeNull()
+  })
+  test('getAccount returns current account when no id given', async () => {
+    const account = makeAccount('alice')
+    await manager.setAccount(account)
+    const result = await manager.getAccount()
+    expect(result).toEqual(account)
+  })
+  test('getAccount returns account by id', async () => {
+    await manager.setAccount(makeAccount('alice'))
+    const bob = makeAccount('bob')
+    await manager.setAccount(bob)
+    const result = await manager.getAccount('bob')
+    expect(result).toEqual(bob)
+  })
+  test('getAccount returns null for unknown id', async () => {
+    await manager.setAccount(makeAccount('alice'))
+    const result = await manager.getAccount('unknown')
+    expect(result).toBeNull()
+  })
+  test('removeAccount removes the account', async () => {
+    await manager.setAccount(makeAccount('alice'))
+    await manager.removeAccount('alice')
+    const loaded = await manager.load()
+    expect(loaded.accounts['alice']).toBeUndefined()
+  })
+  test('removeAccount clears current if it was active', async () => {
+    await manager.setAccount(makeAccount('alice'))
+    await manager.removeAccount('alice')
+    const loaded = await manager.load()
+    expect(loaded.current_account).toBeNull()
+  })
+  test('removeAccount sets next account as current when active is removed', async () => {
+    await manager.setAccount(makeAccount('alice'))
+    await manager.setAccount(makeAccount('bob'))
+    await manager.removeAccount('alice')
+    const loaded = await manager.load()
+    expect(loaded.current_account).toBe('bob')
+  })
+  test('setCurrentAccount updates current account', async () => {
+    await manager.setAccount(makeAccount('alice'))
+    await manager.setAccount(makeAccount('bob'))
+    await manager.setCurrentAccount('bob')
+    const loaded = await manager.load()
+    expect(loaded.current_account).toBe('bob')
+  })
+  test('listAccounts returns correct format', async () => {
+    await manager.setAccount(makeAccount('alice'))
+    await manager.setAccount(makeAccount('bob'))
+    const list = await manager.listAccounts()
+    expect(list).toHaveLength(2)
+    const alice = list.find((a) => a.account_id === 'alice')
+    expect(alice).toBeDefined()
+    expect(alice?.is_current).toBe(true)
+    expect(alice?.device).toBe('DESKTOPMAC')
+    expect(alice?.display_name).toBe('User alice')
+    expect(alice?.created_at).toBeDefined()
+    const bob = list.find((a) => a.account_id === 'bob')
+    expect(bob?.is_current).toBe(false)
+  })
+  test('clearAll removes the credentials file', async () => {
+    await manager.setAccount(makeAccount('alice'))
+    await manager.clearAll()
+    const config = await manager.load()
+    expect(config).toEqual({ current_account: null, accounts: {} })
+  })
+  test('clearAll does not throw if file does not exist', async () => {
+    await expect(manager.clearAll()).resolves.toBeUndefined()
+  })
+})

package/src/platforms/line/credential-manager.ts ADDED Viewed

@@ -0,0 +1,99 @@
+import { existsSync } from 'node:fs'
+import { mkdir, rm, writeFile, readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import type { LineAccountCredentials, LineConfig } from './types'
+export class LineCredentialManager {
+  private configDir: string
+  private credentialsPath: string
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? join(homedir(), '.config', 'agent-messenger')
+    this.credentialsPath = join(this.configDir, 'line-credentials.json')
+  }
+  async load(): Promise<LineConfig> {
+    if (!existsSync(this.credentialsPath)) {
+      return { current_account: null, accounts: {} }
+    }
+    const content = await readFile(this.credentialsPath, 'utf-8')
+    return JSON.parse(content) as LineConfig
+  }
+  async save(config: LineConfig): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    await writeFile(this.credentialsPath, JSON.stringify(config, null, 2), { mode: 0o600 })
+  }
+  async getAccount(accountId?: string): Promise<LineAccountCredentials | null> {
+    const config = await this.load()
+    if (accountId) {
+      return config.accounts[accountId] ?? null
+    }
+    if (!config.current_account) {
+      return null
+    }
+    return config.accounts[config.current_account] ?? null
+  }
+  async setAccount(credentials: LineAccountCredentials): Promise<void> {
+    const config = await this.load()
+    config.accounts[credentials.account_id] = credentials
+    if (!config.current_account) {
+      config.current_account = credentials.account_id
+    }
+    await this.save(config)
+  }
+  async removeAccount(accountId: string): Promise<void> {
+    const config = await this.load()
+    delete config.accounts[accountId]
+    if (config.current_account === accountId) {
+      config.current_account = Object.keys(config.accounts)[0] ?? null
+    }
+    await this.save(config)
+  }
+  async setCurrentAccount(accountId: string): Promise<void> {
+    const config = await this.load()
+    config.current_account = accountId
+    await this.save(config)
+  }
+  async listAccounts(): Promise<
+    Array<{
+      account_id: string
+      display_name?: string
+      device: string
+      is_current: boolean
+      created_at: string
+    }>
+  > {
+    const config = await this.load()
+    return Object.values(config.accounts).map((account) => ({
+      account_id: account.account_id,
+      display_name: account.display_name,
+      device: account.device,
+      is_current: config.current_account === account.account_id,
+      created_at: account.created_at,
+    }))
+  }
+  async clearAll(): Promise<void> {
+    if (existsSync(this.credentialsPath)) {
+      await rm(this.credentialsPath, { force: true })
+    }
+  }
+}
+export { LineCredentialManager as CredentialManager }

package/src/platforms/line/ensure-auth.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { LineCredentialManager } from './credential-manager'
+import type { LineAccountCredentials } from './types'
+export async function ensureLineAuth(accountId?: string): Promise<LineAccountCredentials> {
+  const credManager = new LineCredentialManager()
+  const account = await credManager.getAccount(accountId)
+  if (account?.auth_token) {
+    return account
+  }
+  throw new Error('No LINE credentials found. Run:\n  agent-line auth login')
+}