agent-messenger 1.15.0 → 2.0.0

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

@@ -0,0 +1,277 @@
+import { afterAll, describe, expect, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { InstagramCredentialManager } from '@/platforms/instagram/credential-manager'
+import type { InstagramAccount } from '@/platforms/instagram/types'
+
+const testDirs: string[] = []
+
+function setup(): InstagramCredentialManager {
+  const testConfigDir = join(
+    import.meta.dir,
+    `.test-instagram-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  testDirs.push(testConfigDir)
+  return new InstagramCredentialManager(testConfigDir)
+}
+
+function makeAccount(overrides?: Partial<InstagramAccount>): InstagramAccount {
+  return {
+    account_id: 'test-account',
+    username: 'testuser',
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    ...overrides,
+  }
+}
+
+afterAll(() => {
+  for (const dir of testDirs) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('InstagramCredentialManager', () => {
+  describe('loadConfig', () => {
+    test('returns default config when file does not exist', async () => {
+      const manager = setup()
+      const config = await manager.loadConfig()
+
+      expect(config).toEqual({ current: null, accounts: {} })
+    })
+  })
+
+  describe('saveConfig', () => {
+    test('creates file and can be re-read via loadConfig', async () => {
+      const manager = setup()
+      const config = {
+        current: 'test-account',
+        accounts: {
+          'test-account': makeAccount(),
+        },
+      }
+
+      await manager.saveConfig(config)
+      const loaded = await manager.loadConfig()
+
+      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 specific accountId when no accounts exist', async () => {
+      const manager = setup()
+      const account = await manager.getAccount('nonexistent')
+
+      expect(account).toBeNull()
+    })
+  })
+
+  describe('setAccount', () => {
+    test('round-trips: set then get returns same account', async () => {
+      const manager = setup()
+      const account = makeAccount()
+
+      await manager.setAccount(account)
+      const retrieved = await manager.getAccount('test-account')
+
+      expect(retrieved).toEqual(account)
+    })
+
+    test('sets first account as current automatically', async () => {
+      const manager = setup()
+      const account = makeAccount()
+
+      await manager.setAccount(account)
+      const current = await manager.getAccount()
+
+      expect(current).toEqual(account)
+    })
+
+    test('does not override current when it is already set', 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 current = await manager.getAccount()
+      expect(current?.account_id).toBe('first-account')
+    })
+
+    test('getAccount with normalized ID lookup via createAccountId', async () => {
+      const manager = setup()
+      const account = makeAccount({ account_id: 'my-username' })
+
+      await manager.setAccount(account)
+      const retrieved = await manager.getAccount('My Username')
+
+      expect(retrieved).toEqual(account)
+    })
+  })
+
+  describe('listAccounts', () => {
+    test('returns empty array when no accounts', async () => {
+      const manager = setup()
+      const accounts = await manager.listAccounts()
+
+      expect(accounts).toEqual([])
+    })
+
+    test('returns all accounts with 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('setCurrent', () => {
+    test('switches active account and returns true', 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 result = await manager.setCurrent('second-account')
+      expect(result).toBe(true)
+
+      const current = await manager.getAccount()
+      expect(current?.account_id).toBe('second-account')
+    })
+
+    test('returns false for non-existent account', async () => {
+      const manager = setup()
+
+      const result = await manager.setCurrent('nonexistent')
+
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('removeAccount', () => {
+    test('removes account and adjusts 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)
+
+      const result = await manager.removeAccount('first-account')
+      expect(result).toBe(true)
+
+      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('returns false for non-existent account', async () => {
+      const manager = setup()
+
+      const result = await manager.removeAccount('nonexistent')
+
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('clearCredentials', () => {
+    test('removes credentials file when it exists', async () => {
+      const manager = setup()
+      const account = makeAccount()
+      await manager.setAccount(account)
+
+      const testConfigDir = testDirs[testDirs.length - 1]!
+      const credentialsPath = join(testConfigDir, 'instagram-credentials.json')
+      expect(existsSync(credentialsPath)).toBe(true)
+
+      await manager.clearCredentials()
+
+      expect(existsSync(credentialsPath)).toBe(false)
+    })
+
+    test('does not throw when credentials file does not exist', async () => {
+      const manager = setup()
+
+      await expect(manager.clearCredentials()).resolves.toBeUndefined()
+    })
+  })
+
+  describe('getAccountPaths', () => {
+    test('returns correct paths structure for account ID', async () => {
+      const testConfigDir = join(
+        import.meta.dir,
+        `.test-instagram-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      )
+      testDirs.push(testConfigDir)
+      const manager = new InstagramCredentialManager(testConfigDir)
+
+      const paths = manager.getAccountPaths('test-account')
+
+      expect(paths.account_dir).toBe(join(testConfigDir, 'instagram', 'test-account'))
+      expect(paths.session_path).toBe(join(testConfigDir, 'instagram', 'test-account', 'session.json'))
+    })
+
+    test('normalizes account ID via createAccountId', async () => {
+      const testConfigDir = join(
+        import.meta.dir,
+        `.test-instagram-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      )
+      testDirs.push(testConfigDir)
+      const manager = new InstagramCredentialManager(testConfigDir)
+
+      const paths = manager.getAccountPaths('My Username')
+
+      expect(paths.account_dir).toContain('my-username')
+      expect(paths.session_path).toContain('my-username')
+    })
+  })
+
+  describe('ensureAccountPaths', () => {
+    test('creates directories', async () => {
+      const manager = setup()
+
+      const paths = await manager.ensureAccountPaths('test-account')
+
+      expect(existsSync(paths.account_dir)).toBe(true)
+    })
+
+    test('returns paths structure', async () => {
+      const testConfigDir = join(
+        import.meta.dir,
+        `.test-instagram-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      )
+      testDirs.push(testConfigDir)
+      const manager = new InstagramCredentialManager(testConfigDir)
+
+      const paths = await manager.ensureAccountPaths('my-account')
+
+      expect(paths.account_dir).toBe(join(testConfigDir, 'instagram', 'my-account'))
+      expect(paths.session_path).toBe(join(testConfigDir, 'instagram', 'my-account', 'session.json'))
+    })
+  })
+})

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

@@ -0,0 +1,134 @@
+import { existsSync } from 'node:fs'
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import {
+  createAccountId,
+  type InstagramAccount,
+  type InstagramAccountPaths,
+  type InstagramConfig,
+} from './types'
+
+export class InstagramCredentialManager {
+  private configDir: string
+  private credentialsPath: string
+  private instagramRootDir: string
+
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? join(homedir(), '.config', 'agent-messenger')
+    this.credentialsPath = join(this.configDir, 'instagram-credentials.json')
+    this.instagramRootDir = join(this.configDir, 'instagram')
+  }
+
+  async loadConfig(): Promise<InstagramConfig> {
+    if (!existsSync(this.credentialsPath)) {
+      return { current: null, accounts: {} }
+    }
+
+    try {
+      const content = await readFile(this.credentialsPath, 'utf-8')
+      return JSON.parse(content) as InstagramConfig
+    } catch {
+      return { current: null, accounts: {} }
+    }
+  }
+
+  async saveConfig(config: InstagramConfig): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    await writeFile(this.credentialsPath, JSON.stringify(config, null, 2), { mode: 0o600 })
+  }
+
+  async getAccount(accountId?: string): Promise<InstagramAccount | null> {
+    const config = await this.loadConfig()
+
+    if (!accountId) {
+      return config.current ? (config.accounts[config.current] ?? null) : null
+    }
+
+    const direct = config.accounts[accountId]
+    if (direct) {
+      return direct
+    }
+
+    const normalized = createAccountId(accountId)
+    return config.accounts[normalized] ?? null
+  }
+
+  async listAccounts(): Promise<Array<InstagramAccount & { is_current: boolean }>> {
+    const config = await this.loadConfig()
+
+    return Object.values(config.accounts).map((account) => ({
+      ...account,
+      is_current: account.account_id === config.current,
+    }))
+  }
+
+  async setAccount(account: InstagramAccount): Promise<void> {
+    const config = await this.loadConfig()
+    config.accounts[account.account_id] = account
+
+    if (!config.current) {
+      config.current = account.account_id
+    }
+
+    await this.saveConfig(config)
+  }
+
+  async setCurrent(accountId: string): Promise<boolean> {
+    const config = await this.loadConfig()
+    const account = config.accounts[accountId] ?? config.accounts[createAccountId(accountId)]
+
+    if (!account) {
+      return false
+    }
+
+    config.current = account.account_id
+    await this.saveConfig(config)
+    return true
+  }
+
+  async removeAccount(accountId: string): Promise<boolean> {
+    const config = await this.loadConfig()
+    const account = config.accounts[accountId] ?? config.accounts[createAccountId(accountId)]
+
+    if (!account) {
+      return false
+    }
+
+    delete config.accounts[account.account_id]
+
+    if (config.current === account.account_id) {
+      config.current = Object.keys(config.accounts)[0] ?? null
+    }
+
+    await this.saveConfig(config)
+    await rm(this.getAccountPaths(account.account_id).account_dir, { recursive: true, force: true })
+    return true
+  }
+
+  async clearCredentials(): Promise<void> {
+    if (existsSync(this.credentialsPath)) {
+      await rm(this.credentialsPath, { force: true })
+    }
+
+    if (existsSync(this.instagramRootDir)) {
+      await rm(this.instagramRootDir, { recursive: true, force: true })
+    }
+  }
+
+  getAccountPaths(accountId: string): InstagramAccountPaths {
+    const safeAccountId = createAccountId(accountId)
+    const accountDir = join(this.instagramRootDir, safeAccountId)
+
+    return {
+      account_dir: accountDir,
+      session_path: join(accountDir, 'session.json'),
+    }
+  }
+
+  async ensureAccountPaths(accountId: string): Promise<InstagramAccountPaths> {
+    const paths = this.getAccountPaths(accountId)
+    await mkdir(paths.account_dir, { recursive: true })
+    return paths
+  }
+}

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

@@ -0,0 +1,84 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+import * as fs from 'node:fs'
+
+import { InstagramCredentialManager } from '@/platforms/instagram/credential-manager'
+import { ensureInstagramAuth } from '@/platforms/instagram/ensure-auth'
+import type { InstagramAccount } from '@/platforms/instagram/types'
+
+let getAccountSpy: ReturnType<typeof spyOn>
+let getAccountPathsSpy: ReturnType<typeof spyOn>
+let existsSyncSpy: ReturnType<typeof spyOn>
+let exitSpy: ReturnType<typeof spyOn>
+let consoleSpy: ReturnType<typeof spyOn>
+
+const validAccount: InstagramAccount = {
+  account_id: 'test-account',
+  username: 'testuser',
+  created_at: new Date().toISOString(),
+  updated_at: new Date().toISOString(),
+}
+
+const validPaths = {
+  account_dir: '/tmp/test/instagram/test-account',
+  session_path: '/tmp/test/instagram/test-account/session.json',
+}
+
+beforeEach(() => {
+  getAccountSpy = spyOn(InstagramCredentialManager.prototype, 'getAccount').mockResolvedValue(null)
+
+  getAccountPathsSpy = spyOn(
+    InstagramCredentialManager.prototype,
+    'getAccountPaths',
+  ).mockReturnValue(validPaths)
+
+  existsSyncSpy = spyOn(fs, 'existsSync').mockReturnValue(false)
+
+  exitSpy = spyOn(process, 'exit').mockImplementation((code) => {
+    throw new Error(`process.exit(${code})`)
+  })
+
+  consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
+})
+
+afterEach(() => {
+  getAccountSpy?.mockRestore()
+  getAccountPathsSpy?.mockRestore()
+  existsSyncSpy?.mockRestore()
+  exitSpy?.mockRestore()
+  consoleSpy?.mockRestore()
+})
+
+describe('ensureInstagramAuth', () => {
+  test('exits with error when no account configured', async () => {
+    // given
+    getAccountSpy.mockResolvedValue(null)
+
+    // when / then
+    await expect(ensureInstagramAuth()).rejects.toThrow('process.exit(1)')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+    expect(consoleSpy).toHaveBeenCalled()
+  })
+
+  test('exits with error when session file missing', async () => {
+    // given
+    getAccountSpy.mockResolvedValue(validAccount)
+    existsSyncSpy.mockReturnValue(false)
+
+    // when / then
+    await expect(ensureInstagramAuth()).rejects.toThrow('process.exit(1)')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+    expect(consoleSpy).toHaveBeenCalled()
+  })
+
+  test('succeeds when account and session file exist', async () => {
+    // given
+    getAccountSpy.mockResolvedValue(validAccount)
+    existsSyncSpy.mockReturnValue(true)
+
+    // when
+    await ensureInstagramAuth()
+
+    // then
+    expect(exitSpy).not.toHaveBeenCalled()
+  })
+})

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

@@ -0,0 +1,24 @@
+import { existsSync } from 'node:fs'
+import { formatOutput } from '@/shared/utils/output'
+import { InstagramCredentialManager } from './credential-manager'
+
+export async function ensureInstagramAuth(): Promise<void> {
+  const manager = new InstagramCredentialManager()
+  const account = await manager.getAccount()
+
+  if (!account) {
+    console.log(formatOutput({
+      error: 'Not authenticated. Run "agent-instagram auth login --username <username>" first.',
+    }))
+    process.exit(1)
+  }
+
+  const paths = manager.getAccountPaths(account.account_id)
+
+  if (!existsSync(paths.session_path)) {
+    console.log(formatOutput({
+      error: 'Session expired or missing. Run "agent-instagram auth login --username <username>" to re-authenticate.',
+    }))
+    process.exit(1)
+  }
+}

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

@@ -0,0 +1,44 @@
+import { expect, test } from 'bun:test'
+
+import {
+  createAccountId,
+  extractMediaUrl,
+  extractMessageText,
+  getMessageType,
+  InstagramClient,
+  InstagramCredentialManager,
+  InstagramError,
+  InstagramListener,
+} from '@/platforms/instagram/index'
+
+test('InstagramClient is exported from barrel', () => {
+  expect(typeof InstagramClient).toBe('function')
+})
+
+test('InstagramCredentialManager is exported from barrel', () => {
+  expect(typeof InstagramCredentialManager).toBe('function')
+})
+
+test('InstagramListener is exported from barrel', () => {
+  expect(typeof InstagramListener).toBe('function')
+})
+
+test('InstagramError is exported from barrel', () => {
+  expect(typeof InstagramError).toBe('function')
+})
+
+test('createAccountId is exported from barrel', () => {
+  expect(typeof createAccountId).toBe('function')
+})
+
+test('extractMediaUrl is exported from barrel', () => {
+  expect(typeof extractMediaUrl).toBe('function')
+})
+
+test('extractMessageText is exported from barrel', () => {
+  expect(typeof extractMessageText).toBe('function')
+})
+
+test('getMessageType is exported from barrel', () => {
+  expect(typeof getMessageType).toBe('function')
+})

package/src/platforms/instagram/index.ts

@@ -0,0 +1,16 @@
+export { InstagramClient } from './client'
+export { InstagramCredentialManager } from './credential-manager'
+export { InstagramListener, type InstagramListenerEventMap } from './listener'
+export {
+  createAccountId,
+  extractMediaUrl,
+  extractMessageText,
+  getMessageType,
+  InstagramError,
+  type InstagramAccount,
+  type InstagramAccountPaths,
+  type InstagramChatSummary,
+  type InstagramConfig,
+  type InstagramMessageSummary,
+  type InstagramSessionState,
+} from './types'