agent-messenger 2.27.2 → 2.29.0

package/src/platforms/discord/client.test.ts

@@ -164,6 +164,38 @@ describe('DiscordClient', () => {
       expect(fetchCalls[0].options?.method).toBe('POST')
       expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ content: 'Hello world' }))
     })
+
+    it('includes message_reference when reply_to is provided', async () => {
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', username: 'bot' },
+        content: 'Reply text',
+        timestamp: '2024-01-01T00:00:00.000Z',
+      })
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      await client.sendMessage('ch1', 'Reply text', { reply_to: 'parent123' })
+
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({ content: 'Reply text', message_reference: { message_id: 'parent123' } }),
+      )
+    })
+
+    it('omits message_reference when reply_to is not provided', async () => {
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', username: 'bot' },
+        content: 'Hello world',
+        timestamp: '2024-01-01T00:00:00.000Z',
+      })
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      await client.sendMessage('ch1', 'Hello world')
+
+      expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ content: 'Hello world' }))
+    })
   })
 
   describe('getMessages', () => {
@@ -308,6 +340,60 @@ describe('DiscordClient', () => {
       expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/channels/ch1/messages')
       expect(fetchCalls[0].options?.method).toBe('POST')
     })
+
+    it('includes payload_json with message_reference when reply_to is provided', async () => {
+      const tempFile = '/tmp/test-upload-reply.txt'
+      await Bun.write(tempFile, 'test content')
+
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', username: 'bot' },
+        content: '',
+        timestamp: '2024-01-01T00:00:00.000Z',
+        attachments: [
+          {
+            id: 'att1',
+            filename: 'test-upload-reply.txt',
+            size: 12,
+            url: 'https://cdn.discord.com/attachments/ch1/att1/test-upload-reply.txt',
+          },
+        ],
+      })
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      await client.uploadFile('ch1', tempFile, { reply_to: 'parent123' })
+
+      const formData = fetchCalls[0].options?.body as FormData
+      expect(formData.get('payload_json')).toBe(JSON.stringify({ message_reference: { message_id: 'parent123' } }))
+    })
+
+    it('omits payload_json when reply_to is not provided', async () => {
+      const tempFile = '/tmp/test-upload-no-reply.txt'
+      await Bun.write(tempFile, 'test content')
+
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', username: 'bot' },
+        content: '',
+        timestamp: '2024-01-01T00:00:00.000Z',
+        attachments: [
+          {
+            id: 'att1',
+            filename: 'test-upload-no-reply.txt',
+            size: 12,
+            url: 'https://cdn.discord.com/attachments/ch1/att1/test-upload-no-reply.txt',
+          },
+        ],
+      })
+
+      const client = await new DiscordClient().login({ token: 'test-token' })
+      await client.uploadFile('ch1', tempFile)
+
+      const formData = fetchCalls[0].options?.body as FormData
+      expect(formData.get('payload_json')).toBeNull()
+    })
   })
 
   describe('listFiles', () => {

package/src/platforms/discord/client.ts

@@ -226,8 +226,12 @@ export class DiscordClient {
     return this.request<DiscordChannel>('GET', `/channels/${channelId}`)
   }
 
-  async sendMessage(channelId: string, content: string): Promise<DiscordMessage> {
-    return this.request<DiscordMessage>('POST', `/channels/${channelId}/messages`, { content })
+  async sendMessage(channelId: string, content: string, options?: { reply_to?: string }): Promise<DiscordMessage> {
+    const body: Record<string, unknown> = { content }
+    if (options?.reply_to) {
+      body.message_reference = { message_id: options.reply_to }
+    }
+    return this.request<DiscordMessage>('POST', `/channels/${channelId}/messages`, body)
   }
 
   async getMessages(channelId: string, limit: number = 50): Promise<DiscordMessage[]> {
@@ -270,11 +274,14 @@ export class DiscordClient {
     return this.request<DiscordUser>('GET', `/users/${userId}`)
   }
 
-  async uploadFile(channelId: string, filePath: string): Promise<DiscordFile> {
+  async uploadFile(channelId: string, filePath: string, options?: { reply_to?: string }): Promise<DiscordFile> {
     const fileBuffer = await readFile(filePath)
     const filename = filePath.split('/').pop() || 'file'
 
     const formData = new FormData()
+    if (options?.reply_to) {
+      formData.append('payload_json', JSON.stringify({ message_reference: { message_id: options.reply_to } }))
+    }
     formData.append('files[0]', new Blob([fileBuffer]), filename)
 
     interface MessageWithAttachments extends DiscordMessage {

package/src/platforms/imessage/cli.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env bun
+
+import type { Command as CommandType } from 'commander'
+import { Command } from 'commander'
+
+import pkg from '../../../package.json' with { type: 'json' }
+import { authCommand, chatCommand, doctorCommand, messageCommand, setupCommand, whoamiCommand } from './commands/index'
+import { ensureIMessageAuth } from './ensure-auth'
+
+const UNGUARDED = new Set(['auth', 'setup', 'doctor'])
+
+function isUnguarded(command: CommandType): boolean {
+  let cmd: CommandType | null = command
+  while (cmd) {
+    if (UNGUARDED.has(cmd.name())) return true
+    cmd = cmd.parent
+  }
+  return false
+}
+
+const program = new Command()
+
+program.name('agent-imessage').description('CLI tool for iMessage via imsg (local, on-Mac)').version(pkg.version)
+
+program.hook('preAction', async (_thisCommand, actionCommand) => {
+  if (isUnguarded(actionCommand)) return
+  await ensureIMessageAuth()
+})
+
+program.addCommand(authCommand)
+program.addCommand(setupCommand)
+program.addCommand(doctorCommand)
+program.addCommand(chatCommand)
+program.addCommand(messageCommand)
+program.addCommand(whoamiCommand)
+
+program.parse(process.argv)
+
+export default program

package/src/platforms/imessage/client.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from 'bun:test'
+import { join } from 'node:path'
+
+import { ImsgClient } from './client'
+import { IMessageError } from './types'
+
+const STUB = join(import.meta.dir, 'test-stub-imsg.mjs')
+
+function clientWith(mode = 'ok'): ImsgClient {
+  process.env.IMSG_STUB_MODE = mode
+  return new ImsgClient()
+}
+
+describe('ImsgClient (against stub imsg binary)', () => {
+  it('getVersion returns the imsg version', async () => {
+    const c = await clientWith().login({ binaryPath: STUB })
+    expect(await c.getVersion()).toBe('0.11.1')
+    await c.close()
+  })
+
+  it('connect succeeds and listChats maps group/individual + fields', async () => {
+    const c = await clientWith().login({ binaryPath: STUB })
+    await c.connect()
+    const chats = await c.listChats(10)
+    expect(chats[0]).toMatchObject({ id: 42, name: 'Jane', is_group: false, service: 'iMessage' })
+    expect(chats[1]).toMatchObject({ id: 43, name: 'Crew', is_group: true })
+    expect(chats[1]?.participants).toHaveLength(2)
+    await c.close()
+  })
+
+  it('connect throws full_disk_access when the DB is not readable', async () => {
+    const c = await clientWith('fda_denied').login({ binaryPath: STUB })
+    try {
+      await c.connect()
+      throw new Error('should have thrown')
+    } catch (error) {
+      expect((error as IMessageError).code).toBe('full_disk_access')
+      expect((error as IMessageError).suggestion).toContain('Full Disk Access')
+    } finally {
+      await c.close()
+    }
+  })
+
+  it('getMessages maps fields oldest-first with is_outgoing', async () => {
+    const c = await clientWith().login({ binaryPath: STUB })
+    await c.connect()
+    const msgs = await c.getMessages(42, 10)
+    expect(msgs.map((m) => m.guid)).toEqual(['m1', 'm2'])
+    expect(msgs[0]?.is_outgoing).toBe(false)
+    expect(msgs[1]?.is_outgoing).toBe(true)
+    await c.close()
+  })
+
+  it('sendMessage returns guid/id; send failure maps to send_failed', async () => {
+    const ok = await clientWith('ok').login({ binaryPath: STUB })
+    await ok.connect()
+    expect(await ok.sendMessage({ chatId: 42 }, 'hi')).toMatchObject({ guid: 'sent-guid', id: 99, is_outgoing: true })
+    await ok.close()
+
+    const fail = await clientWith('send_fail').login({ binaryPath: STUB })
+    await fail.connect()
+    try {
+      await fail.sendMessage({ chatId: 42 }, 'hi')
+      throw new Error('should have thrown')
+    } catch (error) {
+      expect((error as IMessageError).code).toBe('send_failed')
+    } finally {
+      await fail.close()
+    }
+  })
+
+  it('watch delivers live notifications', async () => {
+    const c = await clientWith().login({ binaryPath: STUB })
+    await c.connect()
+    const received: string[] = []
+    const stop = await c.watch((m) => received.push(m.guid), { chatId: 42 })
+    await new Promise((r) => setTimeout(r, 120))
+    await stop()
+    await c.close()
+    expect(received).toContain('m3')
+  })
+
+  it('sendReaction: standard via CLI; custom + message-target rejected', async () => {
+    const c = await clientWith().login({ binaryPath: STUB })
+    await c.connect()
+    await expect(c.sendReaction(42, 'love')).resolves.toBeUndefined()
+    await expect(c.sendReaction(42, 'sparkles')).rejects.toMatchObject({ code: 'private_api_required' })
+    await expect(c.sendReaction(42, 'love', 'some-guid')).rejects.toMatchObject({ code: 'private_api_required' })
+    await c.close()
+  })
+
+  it('maps an Automation-denied "imsg react" failure to automation_denied (not send_failed)', async () => {
+    const c = await clientWith('react_automation_denied').login({ binaryPath: STUB })
+    await c.connect()
+    try {
+      await c.sendReaction(42, 'love')
+      throw new Error('should have thrown')
+    } catch (error) {
+      expect((error as IMessageError).code).toBe('automation_denied')
+    } finally {
+      await c.close()
+    }
+  })
+
+  it('maps AppleScript "not authorized" send error to automation_denied (not send_failed)', async () => {
+    const c = await clientWith('automation_denied').login({ binaryPath: STUB })
+    await c.connect()
+    try {
+      await c.sendMessage({ chatId: 42 }, 'hi')
+      throw new Error('should have thrown')
+    } catch (error) {
+      expect((error as IMessageError).code).toBe('automation_denied')
+    } finally {
+      await c.close()
+    }
+  })
+
+  it('close() rejects in-flight requests instead of hanging', async () => {
+    const c = await clientWith().login({ binaryPath: STUB })
+    await c.connect()
+    const pending = c.listChats(1)
+    await c.close()
+    await expect(pending).rejects.toMatchObject({ code: 'rpc_error' })
+  })
+
+  it('imsg_not_found when the binary does not exist', async () => {
+    const c = await new ImsgClient().login({ binaryPath: '/nonexistent/imsg-xyz' })
+    try {
+      await c.connect()
+      throw new Error('should have thrown')
+    } catch (error) {
+      expect((error as IMessageError).code).toBe('imsg_not_found')
+    } finally {
+      await c.close()
+    }
+  })
+})

package/src/platforms/imessage/client.ts

@@ -0,0 +1,253 @@
+import { spawn } from 'node:child_process'
+
+import { classifyImsgFailure } from './errors'
+import { ImsgRpc } from './rpc'
+import { type IMessageChatSummary, type IMessageMessageSummary, type IMessageStatus, IMessageError } from './types'
+
+interface ImsgChat {
+  id: number
+  name?: string | null
+  identifier?: string | null
+  guid?: string | null
+  service?: string | null
+  is_group?: boolean
+  participants?: string[] | null
+  last_message?: ImsgMessage | null
+}
+
+interface ImsgMessage {
+  id: number
+  chat_id: number
+  guid: string
+  sender?: string | null
+  sender_name?: string | null
+  is_from_me?: boolean
+  text?: string | null
+  created_at?: string | null
+}
+
+const STANDARD_REACTIONS = new Set(['love', 'like', 'dislike', 'laugh', 'emphasis', 'question'])
+
+export interface SendTarget {
+  chatId?: number
+  chatGuid?: string
+  chatIdentifier?: string
+  to?: string
+}
+
+export type OneShotRunner = (
+  binaryPath: string,
+  args: string[],
+) => Promise<{ code: number; stdout: string; stderr: string }>
+
+const defaultRunner: OneShotRunner = (binaryPath, args) =>
+  new Promise((resolve, reject) => {
+    let proc: ReturnType<typeof spawn>
+    try {
+      proc = spawn(binaryPath, args, { stdio: ['ignore', 'pipe', 'pipe'] })
+    } catch {
+      reject(new IMessageError(`Could not run "${binaryPath}".`, 'imsg_not_found'))
+      return
+    }
+    let stdout = ''
+    let stderr = ''
+    proc.stdout?.on('data', (c: Buffer) => (stdout += c.toString()))
+    proc.stderr?.on('data', (c: Buffer) => (stderr += c.toString()))
+    proc.once('error', (err: NodeJS.ErrnoException) => {
+      reject(
+        err.code === 'ENOENT'
+          ? new IMessageError(`Could not run "${binaryPath}".`, 'imsg_not_found', {
+              suggestion: 'Install imsg: "brew install steipete/tap/imsg".',
+              doctorCommand: 'agent-imessage doctor',
+            })
+          : err,
+      )
+    })
+    proc.once('close', (code) => resolve({ code: code ?? 0, stdout, stderr }))
+  })
+
+function summarizeMessage(msg: ImsgMessage): IMessageMessageSummary {
+  return {
+    id: msg.id,
+    guid: msg.guid,
+    chat_id: msg.chat_id,
+    from: msg.is_from_me ? '' : (msg.sender ?? ''),
+    from_name: msg.sender_name ?? undefined,
+    is_outgoing: Boolean(msg.is_from_me),
+    timestamp: msg.created_at ?? new Date(0).toISOString(),
+    text: msg.text ?? undefined,
+  }
+}
+
+function summarizeChat(chat: ImsgChat): IMessageChatSummary {
+  return {
+    id: chat.id,
+    guid: chat.guid ?? null,
+    identifier: chat.identifier ?? null,
+    name: chat.name?.trim() || chat.identifier || chat.guid || String(chat.id),
+    service: chat.service ?? 'iMessage',
+    is_group: Boolean(chat.is_group),
+    participants: chat.participants ?? [],
+    last_message: chat.last_message ? summarizeMessage(chat.last_message) : undefined,
+  }
+}
+
+export class ImsgClient {
+  private binaryPath = 'imsg'
+  private region: string | undefined
+  private rpc: ImsgRpc
+  private runner: OneShotRunner
+
+  constructor(deps?: { rpc?: ImsgRpc; runner?: OneShotRunner }) {
+    this.rpc = deps?.rpc ?? new ImsgRpc()
+    this.runner = deps?.runner ?? defaultRunner
+  }
+
+  async login(credentials?: { binaryPath?: string; region?: string }): Promise<this> {
+    if (credentials) {
+      this.binaryPath = credentials.binaryPath ?? 'imsg'
+      this.region = credentials.region
+      return this
+    }
+    const { IMessageCredentialManager } = await import('./credential-manager')
+    const resolved = await new IMessageCredentialManager().resolveAccount()
+    this.binaryPath = resolved?.binary_path ?? 'imsg'
+    this.region = resolved?.region
+    return this
+  }
+
+  async connect(): Promise<void> {
+    await this.rpc.start(this.binaryPath)
+    await this.rpc.request('chats.list', { limit: 1 })
+  }
+
+  async getVersion(): Promise<string | null> {
+    const result = await this.runner(this.binaryPath, ['--version'])
+    if (result.code !== 0) return null
+    return result.stdout.trim() || null
+  }
+
+  async getStatus(): Promise<IMessageStatus> {
+    let version: string | null = null
+    let fullDiskAccess = false
+    try {
+      version = await this.getVersion()
+    } catch {
+      version = null
+    }
+    try {
+      await this.rpc.request('chats.list', { limit: 1 })
+      fullDiskAccess = true
+    } catch {
+      fullDiskAccess = false
+    }
+    return {
+      imsg_version: version,
+      binary_path: this.binaryPath,
+      full_disk_access: fullDiskAccess,
+      automation: 'unknown',
+      bridge_available: false,
+    }
+  }
+
+  async listChats(limit = 25): Promise<IMessageChatSummary[]> {
+    const result = await this.rpc.request<{ chats: ImsgChat[] }>('chats.list', { limit })
+    return result.chats.map(summarizeChat)
+  }
+
+  async searchChats(query: string, limit = 25): Promise<IMessageChatSummary[]> {
+    const all = await this.listChats(Math.max(limit, 100))
+    const lower = query.toLowerCase()
+    return all
+      .filter((c) => c.name.toLowerCase().includes(lower) || (c.identifier ?? '').toLowerCase().includes(lower))
+      .slice(0, limit)
+  }
+
+  async getMessages(chatId: number, limit = 25, start?: string): Promise<IMessageMessageSummary[]> {
+    const result = await this.rpc.request<{ messages: ImsgMessage[] }>('messages.history', {
+      chat_id: chatId,
+      limit,
+      ...(start ? { start } : {}),
+    })
+    return result.messages.map(summarizeMessage).sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp))
+  }
+
+  async sendMessage(target: SendTarget, text: string): Promise<IMessageMessageSummary> {
+    const params: Record<string, unknown> = { text }
+    if (target.chatId !== undefined) params.chat_id = target.chatId
+    else if (target.chatGuid) params.chat_guid = target.chatGuid
+    else if (target.chatIdentifier) params.chat_identifier = target.chatIdentifier
+    else if (target.to) params.to = target.to
+    else throw new IMessageError('A chat id, guid, or recipient is required to send.', 'chat_not_found')
+    if (this.region) params.region = this.region
+
+    const result = await this.rpc.request<{ ok?: boolean; guid?: string; id?: number; service?: string }>(
+      'send',
+      params,
+    )
+    return {
+      id: result.id ?? 0,
+      guid: result.guid ?? '',
+      chat_id: target.chatId ?? 0,
+      from: '',
+      is_outgoing: true,
+      timestamp: new Date().toISOString(),
+      text,
+    }
+  }
+
+  async sendReaction(chatId: number, reaction: string, messageGuid?: string): Promise<void> {
+    if (messageGuid) {
+      throw new IMessageError(
+        'Reacting to a specific message requires the imsg Private API bridge.',
+        'private_api_required',
+        { suggestion: 'Enable the bridge with "imsg launch" (requires SIP disabled).' },
+      )
+    }
+    if (!STANDARD_REACTIONS.has(reaction)) {
+      throw new IMessageError(
+        `Custom reactions require the imsg Private API bridge. Standard tapbacks: ${[...STANDARD_REACTIONS].join(', ')}.`,
+        'private_api_required',
+        { suggestion: 'Enable the bridge with "imsg launch" (requires SIP disabled).' },
+      )
+    }
+    const result = await this.runner(this.binaryPath, [
+      'react',
+      '--chat-id',
+      String(chatId),
+      '--reaction',
+      reaction,
+      '--json',
+    ])
+    if (result.code !== 0) {
+      const detail = result.stderr.trim() || result.stdout.trim() || 'Reaction failed.'
+      throw classifyImsgFailure(detail, 'send_failed')
+    }
+  }
+
+  async watch(
+    onMessage: (msg: IMessageMessageSummary) => void,
+    options: { chatId?: number; sinceRowId?: number; onError?: (msg: string) => void } = {},
+  ): Promise<() => Promise<void>> {
+    const params: Record<string, unknown> = { include_reactions: false }
+    if (options.chatId !== undefined) params.chat_id = options.chatId
+    if (options.sinceRowId !== undefined) params.since_rowid = options.sinceRowId
+
+    const subscription = await this.rpc.subscribe(
+      params,
+      (raw) => onMessage(summarizeMessage(raw as ImsgMessage)),
+      options.onError,
+    )
+    return async () => {
+      await this.rpc.unsubscribe(subscription)
+    }
+  }
+
+  async getProfile(): Promise<IMessageStatus> {
+    return this.getStatus()
+  }
+
+  async close(): Promise<void> {
+    this.rpc.close()
+  }
+}