agent-messenger 1.14.0 → 2.0.0

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

@@ -0,0 +1,401 @@
+import { Writable } from 'node:stream'
+
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { InstagramClient } from '../client'
+import { InstagramCredentialManager } from '../credential-manager'
+import { createAccountId } from '../types'
+
+function isInteractive(): boolean {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY)
+}
+
+async function promptText(message: string): Promise<string | undefined> {
+  const { createInterface } = await import('node:readline/promises')
+  const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true })
+  try {
+    const answer = await rl.question(`${message}: `)
+    return answer.trim() || undefined
+  } finally {
+    rl.close()
+  }
+}
+
+async function promptHidden(message: string): Promise<string | undefined> {
+  const { createInterface } = await import('node:readline/promises')
+  const hiddenOutput = new (class extends Writable {
+    muted = false
+    _write(chunk: Buffer | string, encoding: BufferEncoding, cb: (error?: Error | null) => void): void {
+      if (!this.muted) process.stdout.write(chunk, encoding)
+      cb()
+    }
+  })()
+  const rl = createInterface({ input: process.stdin, output: hiddenOutput, terminal: true })
+  try {
+    hiddenOutput.muted = true
+    process.stdout.write(`${message}: `)
+    const answer = await rl.question('')
+    process.stdout.write('\n')
+    return answer.trim() || undefined
+  } finally {
+    hiddenOutput.muted = false
+    rl.close()
+  }
+}
+
+async function saveAccountAndPrint(
+  manager: InstagramCredentialManager,
+  accountId: string,
+  username: string,
+  userId: string,
+  pretty?: boolean,
+): Promise<void> {
+  const now = new Date().toISOString()
+  await manager.setAccount({
+    account_id: accountId,
+    username,
+    pk: userId,
+    created_at: now,
+    updated_at: now,
+  })
+  await manager.setCurrent(accountId)
+
+  console.log(formatOutput({
+    authenticated: true,
+    account_id: accountId,
+    username,
+  }, pretty))
+}
+
+interface LoginOptions {
+  username?: string
+  password?: string
+  pretty?: boolean
+  debug?: boolean
+}
+
+async function loginAction(options: LoginOptions): Promise<void> {
+  try {
+    const interactive = isInteractive()
+    let { username, password } = options
+
+    if (!username) {
+      if (!interactive) {
+        console.log(formatOutput({
+          error: 'Username required. Use --username <username> --password <password>.',
+        }, options.pretty))
+        process.exit(1)
+      }
+      username = await promptText('Instagram username')
+      if (!username) { console.error('Username is required.'); process.exit(1) }
+    }
+
+    if (!password) {
+      if (!interactive) {
+        console.log(formatOutput({
+          error: 'Password required. Use --username <username> --password <password>.',
+        }, options.pretty))
+        process.exit(1)
+      }
+      password = await promptHidden('Password')
+      if (!password) { console.error('Password is required.'); process.exit(1) }
+    }
+
+    const manager = new InstagramCredentialManager()
+    const accountId = createAccountId(username)
+    const paths = await manager.ensureAccountPaths(accountId)
+
+    const client = new InstagramClient(manager)
+    client.setSessionPath(paths.session_path)
+    if (options.debug) {
+      client.setDebugLog((msg) => console.error(`[debug] ${msg}`))
+    }
+
+    const result = await client.authenticate(username, password)
+
+    if (result.requiresTwoFactor) {
+      const twoFactorIdentifier = (result.twoFactorInfo?.['two_factor_identifier'] as string) ?? ''
+
+      if (interactive) {
+        console.error('\n  Two-factor authentication required.')
+        const code = await promptText('Verification code')
+        if (!code) { console.error('Code is required.'); process.exit(1) }
+
+        const tfResult = await client.twoFactorLogin(username, code, twoFactorIdentifier)
+        await saveAccountAndPrint(manager, accountId, username, tfResult.userId, options.pretty)
+      } else {
+        console.log(formatOutput({
+          two_factor_required: true,
+          two_factor_identifier: twoFactorIdentifier,
+          message: 'Run "agent-instagram auth verify --username <username> --code <code> --identifier <identifier>"',
+        }, options.pretty))
+      }
+      return
+    }
+
+    if (result.challengeRequired) {
+      if (interactive) {
+        await handleInteractiveChallenge(client, manager, accountId, username, result.challengePath!, options.pretty)
+      } else {
+        console.log(formatOutput({
+          challenge_required: true,
+          challenge_path: result.challengePath,
+          message: 'Run "agent-instagram auth challenge --username <username> --method email" then "agent-instagram auth challenge --username <username> --code <code>"',
+        }, options.pretty))
+      }
+      return
+    }
+
+    await saveAccountAndPrint(manager, accountId, username, result.userId, options.pretty)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function handleInteractiveChallenge(
+  client: InstagramClient,
+  manager: InstagramCredentialManager,
+  accountId: string,
+  username: string,
+  challengePath: string,
+  pretty?: boolean,
+): Promise<void> {
+  console.error('\n  Security challenge required by Instagram.')
+  console.error('  Choose verification method:')
+  console.error('  1. Email')
+  console.error('  2. SMS')
+  console.error('')
+
+  const choice = await promptText('Method (1/2)')
+  const method = choice === '2' ? 'sms' as const : 'email' as const
+
+  const sendResult = await client.challengeSendCode(challengePath, method)
+  if (sendResult.contactPoint) {
+    console.error(`\n  Code sent to: ${sendResult.contactPoint}`)
+  } else {
+    console.error('\n  Verification code sent.')
+  }
+
+  const code = await promptText('Verification code')
+  if (!code) { console.error('Code is required.'); process.exit(1) }
+
+  const verifyResult = await client.challengeSubmitCode(challengePath, code)
+  await saveAccountAndPrint(manager, accountId, username, verifyResult.userId, pretty)
+}
+
+interface VerifyOptions {
+  username: string
+  code: string
+  identifier: string
+  pretty?: boolean
+}
+
+async function verifyAction(options: VerifyOptions): Promise<void> {
+  try {
+    const manager = new InstagramCredentialManager()
+    const accountId = createAccountId(options.username)
+    const paths = await manager.ensureAccountPaths(accountId)
+
+    const client = new InstagramClient(manager)
+    client.setSessionPath(paths.session_path)
+
+    const result = await client.twoFactorLogin(
+      options.username,
+      options.code,
+      options.identifier,
+    )
+
+    await saveAccountAndPrint(manager, accountId, options.username, result.userId, options.pretty)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+interface ChallengeOptions {
+  username: string
+  method?: string
+  code?: string
+  pretty?: boolean
+}
+
+async function challengeAction(options: ChallengeOptions): Promise<void> {
+  try {
+    const manager = new InstagramCredentialManager()
+    const accountId = createAccountId(options.username)
+    const paths = await manager.ensureAccountPaths(accountId)
+
+    const client = new InstagramClient(manager)
+    client.setSessionPath(paths.session_path)
+    await client.loadSession(paths.session_path)
+
+    const challengePath = client.getChallengePath()
+    if (!challengePath) {
+      console.log(formatOutput({
+        error: 'No pending challenge found. Run "agent-instagram auth login" first.',
+      }, options.pretty))
+      process.exit(1)
+    }
+
+    if (options.code) {
+      const result = await client.challengeSubmitCode(challengePath, options.code)
+      await saveAccountAndPrint(manager, accountId, options.username, result.userId, options.pretty)
+    } else {
+      const method = (options.method === 'sms' ? 'sms' : 'email') as 'email' | 'sms'
+      const result = await client.challengeSendCode(challengePath, method)
+
+      console.log(formatOutput({
+        code_sent: true,
+        contact_point: result.contactPoint,
+        step_name: result.stepName,
+        message: `Verification code sent. Run "agent-instagram auth challenge --username ${options.username} --code <code>" to complete.`,
+      }, options.pretty))
+    }
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function statusAction(options: { account?: string; pretty?: boolean }): Promise<void> {
+  try {
+    const manager = new InstagramCredentialManager()
+    const account = await manager.getAccount(options.account)
+
+    if (!account) {
+      console.log(formatOutput({
+        error: options.account
+          ? `Instagram account "${options.account}" not found.`
+          : 'No Instagram account configured. Run "auth login" first.',
+      }, options.pretty))
+      process.exit(1)
+    }
+
+    console.log(formatOutput({
+      account_id: account.account_id,
+      username: account.username,
+      full_name: account.full_name,
+      pk: account.pk,
+      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 manager = new InstagramCredentialManager()
+    const accounts = await manager.listAccounts()
+
+    console.log(formatOutput(
+      accounts.map((account) => ({
+        account_id: account.account_id,
+        username: account.username,
+        full_name: account.full_name,
+        pk: account.pk,
+        created_at: account.created_at,
+        updated_at: account.updated_at,
+        is_current: account.is_current,
+      })),
+      options.pretty,
+    ))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function useAction(accountId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const manager = new InstagramCredentialManager()
+    const found = await manager.setCurrent(accountId)
+
+    if (!found) {
+      console.log(formatOutput({ error: `Instagram account "${accountId}" not found.` }, options.pretty))
+      process.exit(1)
+    }
+
+    const current = await manager.getAccount()
+    console.log(formatOutput({ success: true, account_id: current?.account_id }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function logoutAction(options: { account?: string; pretty?: boolean }): Promise<void> {
+  try {
+    const manager = new InstagramCredentialManager()
+    const account = await manager.getAccount(options.account)
+
+    if (!account) {
+      console.log(formatOutput({
+        error: options.account
+          ? `Instagram account "${options.account}" not found.`
+          : 'No Instagram account configured.',
+      }, options.pretty))
+      process.exit(1)
+    }
+
+    await manager.removeAccount(account.account_id)
+    console.log(formatOutput({ success: true, account_id: account.account_id, logged_out: true }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const authCommand = new Command('auth')
+  .description('Instagram authentication commands')
+  .addCommand(
+    new Command('login')
+      .description('Log in to Instagram; prompts interactively or accepts flags for AI agents')
+      .option('--username <username>', 'Instagram username')
+      .option('--password <password>', 'Instagram password')
+      .option('--pretty', 'Pretty print JSON output')
+      .option('--debug', 'Show raw API responses')
+      .action(loginAction),
+  )
+  .addCommand(
+    new Command('verify')
+      .description('Complete two-factor authentication (non-interactive)')
+      .requiredOption('--username <username>', 'Instagram username')
+      .requiredOption('--code <code>', 'Two-factor verification code')
+      .requiredOption('--identifier <identifier>', 'Two-factor identifier from login response')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(verifyAction),
+  )
+  .addCommand(
+    new Command('challenge')
+      .description('Resolve a security challenge (non-interactive)')
+      .requiredOption('--username <username>', 'Instagram username')
+      .option('--method <method>', 'Verification method: email or sms', 'email')
+      .option('--code <code>', 'Verification code received via email/sms')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(challengeAction),
+  )
+  .addCommand(
+    new Command('status')
+      .description('Show authentication status')
+      .option('--account <id>', 'Use a specific Instagram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(statusAction),
+  )
+  .addCommand(
+    new Command('list')
+      .description('List stored Instagram accounts')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('use')
+      .description('Switch the current Instagram account')
+      .argument('<account>', 'Account identifier')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(useAction),
+  )
+  .addCommand(
+    new Command('logout')
+      .description('Remove stored credentials and session')
+      .option('--account <id>', 'Use a specific Instagram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(logoutAction),
+  )

package/src/platforms/instagram/commands/chat.ts

@@ -0,0 +1,49 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { parseLimitOption, withInstagramClient } from './shared'
+
+async function listAction(options: { account?: string; pretty?: boolean; limit?: string }): Promise<void> {
+  try {
+    const limit = parseLimitOption(options.limit, 20)
+    const chats = await withInstagramClient(options, (client) => client.listChats(limit))
+    console.log(formatOutput(chats, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function searchAction(
+  query: string,
+  options: { account?: string; pretty?: boolean; limit?: string },
+): Promise<void> {
+  try {
+    const limit = parseLimitOption(options.limit, 20)
+    const chats = await withInstagramClient(options, (client) => client.searchChats(query, limit))
+    console.log(formatOutput(chats, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const chatCommand = new Command('chat')
+  .description('Instagram chat commands')
+  .addCommand(
+    new Command('list')
+      .description('List DM conversations')
+      .option('--limit <n>', 'Number of chats to fetch', '20')
+      .option('--account <id>', 'Use a specific Instagram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('search')
+      .description('Search DM conversations by name')
+      .argument('<query>', 'Search query')
+      .option('--limit <n>', 'Number of results to return', '20')
+      .option('--account <id>', 'Use a specific Instagram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(searchAction),
+  )

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

@@ -0,0 +1,3 @@
+export { authCommand } from './auth'
+export { chatCommand } from './chat'
+export { messageCommand } from './message'

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

@@ -0,0 +1,134 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { parseLimitOption, withInstagramClient } from './shared'
+
+async function listAction(
+  threadId: string,
+  options: { account?: string; pretty?: boolean; limit?: string },
+): Promise<void> {
+  try {
+    const limit = parseLimitOption(options.limit, 25)
+    const messages = await withInstagramClient(options, (client) => client.getMessages(threadId, limit))
+    console.log(formatOutput(messages, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function sendAction(
+  threadId: string,
+  text: string,
+  options: { account?: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const message = await withInstagramClient(options, (client) => client.sendMessage(threadId, text))
+    console.log(formatOutput(message, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function sendToAction(
+  username: string,
+  text: string,
+  options: { account?: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const message = await withInstagramClient(options, async (client) => {
+      const cleaned = username.replace(/^@/, '')
+      const users = await client.searchUsers(cleaned)
+      const exactMatch = users.find((u) => u.username.toLowerCase() === cleaned.toLowerCase())
+      if (!exactMatch) {
+        throw new (await import('../types')).InstagramError(
+          `User "${cleaned}" not found. Search returned: ${users.map((u) => u.username).join(', ') || 'no results'}`,
+          'user_not_found',
+        )
+      }
+      return client.sendMessageToUser(exactMatch.pk, text)
+    })
+    console.log(formatOutput(message, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function searchAction(
+  query: string,
+  options: { account?: string; pretty?: boolean; limit?: string; thread?: string },
+): Promise<void> {
+  try {
+    const limit = parseLimitOption(options.limit, 20)
+    const messages = await withInstagramClient(options, (client) =>
+      client.searchMessages(query, { threadId: options.thread, limit }),
+    )
+    console.log(formatOutput(messages, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function searchUsersAction(
+  query: string,
+  options: { account?: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const users = await withInstagramClient(options, (client) => client.searchUsers(query))
+    console.log(formatOutput(users, options.pretty))
+    process.exit(0)
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const messageCommand = new Command('message')
+  .description('Instagram message commands')
+  .addCommand(
+    new Command('list')
+      .description('List messages from a DM thread')
+      .argument('<thread-id>', 'Thread ID')
+      .option('--limit <n>', 'Number of messages to fetch', '25')
+      .option('--account <id>', 'Use a specific Instagram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('send')
+      .description('Send a text message to a DM thread')
+      .argument('<thread-id>', 'Thread ID')
+      .argument('<text>', 'Message text')
+      .option('--account <id>', 'Use a specific Instagram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(sendAction),
+  )
+  .addCommand(
+    new Command('send-to')
+      .description('Send a text message to a user by @username')
+      .argument('<username>', 'Instagram @username')
+      .argument('<text>', 'Message text')
+      .option('--account <id>', 'Use a specific Instagram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(sendToAction),
+  )
+  .addCommand(
+    new Command('search')
+      .description('Search messages by text content')
+      .argument('<query>', 'Text to search for')
+      .option('--thread <id>', 'Search within a specific thread')
+      .option('--limit <n>', 'Maximum results', '20')
+      .option('--account <id>', 'Use a specific Instagram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(searchAction),
+  )
+  .addCommand(
+    new Command('search-users')
+      .description('Search Instagram users by username')
+      .argument('<query>', 'Search query')
+      .option('--account <id>', 'Use a specific Instagram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(searchUsersAction),
+  )

package/src/platforms/instagram/commands/shared.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from 'bun:test'
+
+import { parseLimitOption } from '@/platforms/instagram/commands/shared'
+import { InstagramError } from '@/platforms/instagram/types'
+
+describe('parseLimitOption', () => {
+  test('returns parsed integer for valid input', () => {
+    expect(parseLimitOption('10', 20)).toBe(10)
+  })
+
+  test('returns default when undefined', () => {
+    expect(parseLimitOption(undefined, 20)).toBe(20)
+  })
+
+  test('trims whitespace', () => {
+    expect(parseLimitOption('  15  ', 20)).toBe(15)
+  })
+
+  test('throws InstagramError for non-numeric input', () => {
+    expect(() => parseLimitOption('abc', 20)).toThrow(InstagramError)
+  })
+
+  test('throws for zero', () => {
+    expect(() => parseLimitOption('0', 20)).toThrow(InstagramError)
+  })
+
+  test('throws for negative numbers', () => {
+    expect(() => parseLimitOption('-5', 20)).toThrow(InstagramError)
+  })
+
+  test('throws for values exceeding default maxValue', () => {
+    expect(() => parseLimitOption('101', 20)).toThrow(InstagramError)
+  })
+
+  test('respects custom maxValue', () => {
+    expect(parseLimitOption('50', 20, 50)).toBe(50)
+    expect(() => parseLimitOption('51', 20, 50)).toThrow(InstagramError)
+  })
+
+  test('throws for decimal numbers', () => {
+    expect(() => parseLimitOption('10.5', 20)).toThrow(InstagramError)
+  })
+
+  test('accepts boundary value 1', () => {
+    expect(parseLimitOption('1', 20)).toBe(1)
+  })
+
+  test('accepts boundary value 100', () => {
+    expect(parseLimitOption('100', 20)).toBe(100)
+  })
+})

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

@@ -0,0 +1,55 @@
+import { formatOutput } from '@/shared/utils/output'
+import { InstagramClient } from '../client'
+import { InstagramCredentialManager } from '../credential-manager'
+import { InstagramError } from '../types'
+
+export interface AccountOption {
+  account?: string
+  pretty?: boolean
+}
+
+export function parseLimitOption(
+  rawLimit: string | undefined,
+  defaultValue: number,
+  maxValue = 100,
+): number {
+  const trimmed = (rawLimit ?? `${defaultValue}`).trim()
+
+  if (!/^\d+$/.test(trimmed)) {
+    throw new InstagramError(`--limit must be an integer between 1 and ${maxValue}.`, 'invalid_limit')
+  }
+
+  const parsed = Number.parseInt(trimmed, 10)
+
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > maxValue) {
+    throw new InstagramError(`--limit must be an integer between 1 and ${maxValue}.`, 'invalid_limit')
+  }
+
+  return parsed
+}
+
+export async function withInstagramClient<T>(
+  options: AccountOption,
+  fn: (client: InstagramClient) => Promise<T>,
+): Promise<T> {
+  const manager = new InstagramCredentialManager()
+  const account = await manager.getAccount(options.account)
+
+  if (!account) {
+    console.log(
+      formatOutput(
+        {
+          error: options.account
+            ? `Instagram account "${options.account}" not found. Run "agent-instagram auth login --username <username>" first.`
+            : 'Not authenticated. Run "agent-instagram auth login --username <username>" first.',
+        },
+        options.pretty,
+      ),
+    )
+    process.exit(1)
+  }
+
+  const client = new InstagramClient(manager)
+  await client.login(undefined, account.account_id)
+  return fn(client)
+}