agent-messenger 1.14.0 → 2.0.0

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

@@ -0,0 +1,38 @@
+import { formatOutput } from '@/shared/utils/output'
+import { KakaoTalkClient } from '../client'
+import { KakaoCredentialManager } from '../credential-manager'
+
+export interface AccountOption {
+  account?: string
+  pretty?: boolean
+}
+
+export async function withKakaoClient<T>(
+  options: AccountOption,
+  fn: (client: KakaoTalkClient) => Promise<T>,
+): Promise<T> {
+  const manager = new KakaoCredentialManager()
+  const account = await manager.getAccount(options.account)
+
+  if (!account) {
+    console.log(
+      formatOutput(
+        {
+          error: options.account
+            ? `KakaoTalk account "${options.account}" not found. Run "agent-kakaotalk auth list" to see available accounts.`
+            : 'No KakaoTalk credentials found. Run:\n  agent-kakaotalk auth login     (recommended — registers as sub-device, desktop app stays running)',
+        },
+        options.pretty,
+      ),
+    )
+    process.exit(1)
+  }
+
+  const client = new KakaoTalkClient()
+  await client.login(undefined, account.account_id)
+  try {
+    return await fn(client)
+  } finally {
+    client.close()
+  }
+}

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

@@ -0,0 +1,231 @@
+import { afterAll, describe, expect, test } from 'bun:test'
+import { rmSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { KakaoCredentialManager } from './credential-manager'
+import type { KakaoAccountCredentials } from './types'
+
+const testDirs: string[] = []
+
+function setup(): KakaoCredentialManager {
+  const testConfigDir = join(
+    import.meta.dir,
+    `.test-kakao-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  testDirs.push(testConfigDir)
+  return new KakaoCredentialManager(testConfigDir)
+}
+
+function makeAccount(overrides?: Partial<KakaoAccountCredentials>): KakaoAccountCredentials {
+  return {
+    account_id: 'test-account',
+    oauth_token: 'oauth-token-123',
+    user_id: 'user-123',
+    refresh_token: 'refresh-token-123',
+    device_uuid: 'device-uuid-123',
+    device_type: 'tablet',
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    ...overrides,
+  }
+}
+
+afterAll(() => {
+  for (const dir of testDirs) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('KakaoCredentialManager', () => {
+  describe('load', () => {
+    test('returns default config when file does not exist', async () => {
+      const manager = setup()
+      const config = await manager.load()
+
+      expect(config).toEqual({ current_account: null, accounts: {} })
+    })
+  })
+
+  describe('save/load round-trip', () => {
+    test('creates file and can be re-read via load', async () => {
+      const manager = setup()
+      const account = makeAccount()
+      const config = {
+        current_account: 'test-account',
+        accounts: {
+          'test-account': account,
+        },
+      }
+
+      await manager.save(config)
+      const loaded = await manager.load()
+
+      expect(loaded).toEqual(config)
+    })
+  })
+
+  describe('getAccount', () => {
+    test('returns null when no accounts exist', async () => {
+      const manager = setup()
+      const account = await manager.getAccount()
+
+      expect(account).toBeNull()
+    })
+
+    test('returns null for nonexistent account ID', async () => {
+      const manager = setup()
+      const account = await manager.getAccount('nonexistent')
+
+      expect(account).toBeNull()
+    })
+
+    test('returns account by explicit ID', async () => {
+      const manager = setup()
+      const account = makeAccount()
+
+      await manager.setAccount(account)
+      const retrieved = await manager.getAccount('test-account')
+
+      expect(retrieved).toEqual(account)
+    })
+
+    test('returns current account when no ID given', async () => {
+      const manager = setup()
+      const account = makeAccount()
+
+      await manager.setAccount(account)
+      const current = await manager.getAccount()
+
+      expect(current).toEqual(account)
+    })
+  })
+
+  describe('setAccount', () => {
+    test('stores account and auto-sets current_account if null', async () => {
+      const manager = setup()
+      const account = makeAccount()
+
+      await manager.setAccount(account)
+      const config = await manager.load()
+
+      expect(config.current_account).toBe('test-account')
+      expect(config.accounts['test-account']).toEqual(account)
+    })
+
+    test('does NOT override existing current_account', async () => {
+      const manager = setup()
+      const first = makeAccount({ account_id: 'first-account' })
+      const second = makeAccount({ account_id: 'second-account' })
+
+      await manager.setAccount(first)
+      await manager.setAccount(second)
+
+      const config = await manager.load()
+      expect(config.current_account).toBe('first-account')
+    })
+  })
+
+  describe('listAccounts', () => {
+    test('returns empty array for empty config', async () => {
+      const manager = setup()
+      const accounts = await manager.listAccounts()
+
+      expect(accounts).toEqual([])
+    })
+
+    test('returns all accounts with correct is_current flag', async () => {
+      const manager = setup()
+      const first = makeAccount({ account_id: 'first-account' })
+      const second = makeAccount({ account_id: 'second-account' })
+
+      await manager.setAccount(first)
+      await manager.setAccount(second)
+
+      const accounts = await manager.listAccounts()
+
+      expect(accounts).toHaveLength(2)
+      const firstResult = accounts.find((a) => a.account_id === 'first-account')
+      const secondResult = accounts.find((a) => a.account_id === 'second-account')
+      expect(firstResult?.is_current).toBe(true)
+      expect(secondResult?.is_current).toBe(false)
+    })
+  })
+
+  describe('setCurrentAccount', () => {
+    test('switches active account', async () => {
+      const manager = setup()
+      const first = makeAccount({ account_id: 'first-account' })
+      const second = makeAccount({ account_id: 'second-account' })
+
+      await manager.setAccount(first)
+      await manager.setAccount(second)
+      await manager.setCurrentAccount('second-account')
+
+      const current = await manager.getAccount()
+      expect(current?.account_id).toBe('second-account')
+    })
+  })
+
+  describe('removeAccount', () => {
+    test('removes and rotates current to next available', async () => {
+      const manager = setup()
+      const first = makeAccount({ account_id: 'first-account' })
+      const second = makeAccount({ account_id: 'second-account' })
+
+      await manager.setAccount(first)
+      await manager.setAccount(second)
+      await manager.removeAccount('first-account')
+
+      const accounts = await manager.listAccounts()
+      expect(accounts).toHaveLength(1)
+      expect(accounts[0]?.account_id).toBe('second-account')
+
+      const current = await manager.getAccount()
+      expect(current?.account_id).toBe('second-account')
+    })
+
+    test('handles removing non-current account', async () => {
+      const manager = setup()
+      const first = makeAccount({ account_id: 'first-account' })
+      const second = makeAccount({ account_id: 'second-account' })
+
+      await manager.setAccount(first)
+      await manager.setAccount(second)
+      await manager.removeAccount('second-account')
+
+      const accounts = await manager.listAccounts()
+      expect(accounts).toHaveLength(1)
+      expect(accounts[0]?.account_id).toBe('first-account')
+
+      // current_account should still be first-account
+      const config = await manager.load()
+      expect(config.current_account).toBe('first-account')
+    })
+  })
+
+  describe('savePendingLogin/loadPendingLogin/clearPendingLogin', () => {
+    test('full lifecycle: save, load, clear', async () => {
+      const manager = setup()
+      const state = {
+        device_uuid: 'uuid-abc',
+        device_type: 'tablet' as const,
+        email: 'user@example.com',
+        created_at: new Date().toISOString(),
+      }
+
+      // given nothing saved
+      const initial = await manager.loadPendingLogin()
+      expect(initial).toBeNull()
+
+      // when saved
+      await manager.savePendingLogin(state)
+      const loaded = await manager.loadPendingLogin()
+      expect(loaded).toEqual(state)
+
+      // when cleared
+      await manager.clearPendingLogin()
+      const afterClear = await manager.loadPendingLogin()
+      expect(afterClear).toBeNull()
+    })
+  })
+})

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

@@ -0,0 +1,110 @@
+import { existsSync } from 'node:fs'
+import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import type { KakaoAccountCredentials, KakaoConfig, KakaoDeviceType } from './types'
+
+export interface PendingLoginState {
+  device_uuid: string
+  device_type: KakaoDeviceType
+  email: string
+  created_at: string
+}
+
+export class KakaoCredentialManager {
+  private configDir: string
+  private credentialsPath: string
+  private pendingLoginPath: string
+
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? join(homedir(), '.config', 'agent-messenger')
+    this.credentialsPath = join(this.configDir, 'kakaotalk-credentials.json')
+    this.pendingLoginPath = join(this.configDir, 'kakaotalk-pending-login.json')
+  }
+
+  async load(): Promise<KakaoConfig> {
+    if (!existsSync(this.credentialsPath)) {
+      return { current_account: null, accounts: {} }
+    }
+
+    const content = await readFile(this.credentialsPath, 'utf-8')
+    return JSON.parse(content) as KakaoConfig
+  }
+
+  async save(config: KakaoConfig): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    await writeFile(this.credentialsPath, JSON.stringify(config, null, 2))
+    await chmod(this.credentialsPath, 0o600)
+  }
+
+  async getAccount(id?: string): Promise<KakaoAccountCredentials | null> {
+    const config = await this.load()
+
+    if (id) {
+      return config.accounts[id] ?? null
+    }
+
+    if (!config.current_account) {
+      return null
+    }
+
+    return config.accounts[config.current_account] ?? null
+  }
+
+  async setAccount(account: KakaoAccountCredentials): Promise<void> {
+    const config = await this.load()
+    config.accounts[account.account_id] = account
+
+    if (!config.current_account) {
+      config.current_account = account.account_id
+    }
+
+    await this.save(config)
+  }
+
+  async removeAccount(id: string): Promise<void> {
+    const config = await this.load()
+    delete config.accounts[id]
+
+    if (config.current_account === id) {
+      config.current_account = Object.keys(config.accounts)[0] ?? null
+    }
+
+    await this.save(config)
+  }
+
+  async listAccounts(): Promise<Array<KakaoAccountCredentials & { is_current: boolean }>> {
+    const config = await this.load()
+    return Object.values(config.accounts).map((account) => ({
+      ...account,
+      is_current: account.account_id === config.current_account,
+    }))
+  }
+
+  async setCurrentAccount(id: string): Promise<void> {
+    const config = await this.load()
+    config.current_account = id
+    await this.save(config)
+  }
+
+  async savePendingLogin(state: PendingLoginState): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    await writeFile(this.pendingLoginPath, JSON.stringify(state, null, 2))
+    await chmod(this.pendingLoginPath, 0o600)
+  }
+
+  async loadPendingLogin(): Promise<PendingLoginState | null> {
+    if (!existsSync(this.pendingLoginPath)) return null
+    const content = await readFile(this.pendingLoginPath, 'utf-8')
+    return JSON.parse(content) as PendingLoginState
+  }
+
+  async clearPendingLogin(): Promise<void> {
+    if (existsSync(this.pendingLoginPath)) {
+      await rm(this.pendingLoginPath, { force: true })
+    }
+  }
+}
+
+export { KakaoCredentialManager as CredentialManager }

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

@@ -0,0 +1,16 @@
+import { CredentialManager } from './credential-manager'
+import type { KakaoAccountCredentials } from './types'
+
+export async function ensureKakaoAuth(accountId?: string): Promise<KakaoAccountCredentials> {
+  const credManager = new CredentialManager()
+  const account = await credManager.getAccount(accountId)
+
+  if (account?.oauth_token) {
+    return account
+  }
+
+  throw new Error(
+    'No KakaoTalk credentials found. Run:\n' +
+      '  agent-kakaotalk auth login     (recommended — registers as sub-device, desktop app stays running)',
+  )
+}

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

@@ -0,0 +1,68 @@
+import { expect, test } from 'bun:test'
+import {
+  CredentialManager,
+  KakaoAccountCredentialsSchema,
+  KakaoCredentialManager,
+  KakaoChatSchema,
+  KakaoConfigSchema,
+  KakaoMessageSchema,
+  KakaoSendResultSchema,
+  KakaoTalkClient,
+  KakaoTalkError,
+  KakaoTalkListener,
+  KakaoTalkPushMemberEventSchema,
+  KakaoTalkPushMessageEventSchema,
+  KakaoTalkPushReadEventSchema,
+} from '@/platforms/kakaotalk/index'
+
+test('KakaoTalkClient is exported from barrel', () => {
+  expect(typeof KakaoTalkClient).toBe('function')
+})
+
+test('KakaoTalkError is exported from barrel', () => {
+  expect(typeof KakaoTalkError).toBe('function')
+})
+
+test('CredentialManager is exported from barrel', () => {
+  expect(typeof CredentialManager).toBe('function')
+})
+
+test('KakaoCredentialManager is exported from barrel', () => {
+  expect(typeof KakaoCredentialManager).toBe('function')
+})
+
+test('KakaoTalkListener is exported from barrel', () => {
+  expect(typeof KakaoTalkListener).toBe('function')
+})
+
+test('KakaoChatSchema is exported from barrel', () => {
+  expect(typeof KakaoChatSchema.parse).toBe('function')
+})
+
+test('KakaoMessageSchema is exported from barrel', () => {
+  expect(typeof KakaoMessageSchema.parse).toBe('function')
+})
+
+test('KakaoSendResultSchema is exported from barrel', () => {
+  expect(typeof KakaoSendResultSchema.parse).toBe('function')
+})
+
+test('KakaoAccountCredentialsSchema is exported from barrel', () => {
+  expect(typeof KakaoAccountCredentialsSchema.parse).toBe('function')
+})
+
+test('KakaoConfigSchema is exported from barrel', () => {
+  expect(typeof KakaoConfigSchema.parse).toBe('function')
+})
+
+test('KakaoTalkPushMessageEventSchema is exported from barrel', () => {
+  expect(typeof KakaoTalkPushMessageEventSchema.parse).toBe('function')
+})
+
+test('KakaoTalkPushMemberEventSchema is exported from barrel', () => {
+  expect(typeof KakaoTalkPushMemberEventSchema.parse).toBe('function')
+})
+
+test('KakaoTalkPushReadEventSchema is exported from barrel', () => {
+  expect(typeof KakaoTalkPushReadEventSchema.parse).toBe('function')
+})

package/src/platforms/kakaotalk/index.ts

@@ -0,0 +1,30 @@
+export { KakaoTalkClient, KakaoTalkError } from './client'
+export { KakaoCredentialManager, CredentialManager } from './credential-manager'
+export { KakaoTalkListener } from './listener'
+export type { PendingLoginState } from './credential-manager'
+export type {
+  KakaoAccountCredentials,
+  KakaoChat,
+  KakaoConfig,
+  KakaoDeviceType,
+  KakaoMessage,
+  KakaoSendResult,
+  KakaoTalkListenerEventMap,
+  KakaoTalkPushEvent,
+  KakaoTalkPushGenericEvent,
+  KakaoTalkPushMemberEvent,
+  KakaoTalkPushMessageEvent,
+  KakaoTalkPushReadEvent,
+} from './types'
+export {
+  KakaoAccountCredentialsSchema,
+  KakaoChatSchema,
+  KakaoConfigSchema,
+  KakaoMessageSchema,
+  KakaoSendResultSchema,
+  KakaoTalkPushMemberEventSchema,
+  KakaoTalkPushMessageEventSchema,
+  KakaoTalkPushReadEventSchema,
+} from './types'
+
+