agent-messenger 2.17.0 → 2.19.0

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

@@ -3,6 +3,7 @@ import { Writable } from 'node:stream'
 import { Command } from 'commander'
 
 import { handleError } from '@/shared/utils/error-handler'
+import { hasTTY, isInteractive } from '@/shared/utils/interactive'
 import { formatOutput } from '@/shared/utils/output'
 import { info, error, debug } from '@/shared/utils/stderr'
 
@@ -11,23 +12,6 @@ import { CredentialManager } from '../credential-manager'
 import { KakaoTokenExtractor } from '../token-extractor'
 import { KAKAO_NEXT_ACTIONS, type KakaoAuthOptions, type KakaoDeviceType, type KakaoLoginResult } from '../types'
 
-function isInteractiveSession(): boolean {
-  return Boolean(process.stdin.isTTY && process.stdout.isTTY)
-}
-
-function hasTTY(): boolean {
-  try {
-    const { openSync, closeSync } = require('node:fs') as typeof import('node:fs')
-    // CONIN$ is the Windows console input device; /dev/tty is the Unix equivalent
-    const ttyDevice = process.platform === 'win32' ? 'CONIN$' : '/dev/tty'
-    const fd = openSync(ttyDevice, 'r')
-    closeSync(fd)
-    return true
-  } catch {
-    return false
-  }
-}
-
 async function promptPasswordGUI(email?: string): Promise<string | undefined> {
   const { execSync } = require('node:child_process') as typeof import('node:child_process')
 
@@ -233,7 +217,7 @@ async function promptHiddenTTY(message: string): Promise<string | undefined> {
 async function loginAction(options: KakaoAuthOptions): Promise<void> {
   try {
     const credManager = new CredentialManager()
-    const interactive = isInteractiveSession()
+    const interactive = isInteractive()
 
     let { email, password, deviceType, force } = options
 

package/src/platforms/kakaotalk/commands/message.test.ts

@@ -112,6 +112,48 @@ describe('message commands', () => {
         expect.any(Function),
       )
     })
+
+    it('resolves --reply-to from chat history and sends a quoted reply', async () => {
+      // given
+      mockGetMessages.mockImplementation(() =>
+        Promise.resolve([
+          { log_id: '10', type: 1, author_id: 5, author_name: null, message: 'earlier', attachment: null, sent_at: 1 },
+          { log_id: '42', type: 2, author_id: 7, author_name: null, message: 'target', attachment: null, sent_at: 2 },
+        ]),
+      )
+
+      // when
+      await messageCommand.parseAsync(['send', 'chat-123', 'replying', '--reply-to', '42'], { from: 'user' })
+
+      // then
+      expect(mockGetMessages).toHaveBeenCalledWith('chat-123', { count: 100 })
+      expect(mockSendMessage).toHaveBeenCalledWith('chat-123', 'replying', {
+        replyTo: { log_id: '42', author_id: 7, message: 'target', type: 2 },
+      })
+    })
+
+    it('errors when --reply-to log-id is not found in recent history', async () => {
+      // given
+      mockGetMessages.mockImplementation(() =>
+        Promise.resolve([
+          { log_id: '10', type: 1, author_id: 5, author_name: null, message: 'earlier', attachment: null, sent_at: 1 },
+        ]),
+      )
+      const exitSpy = mock((_code?: number): never => {
+        throw new Error('process.exit called')
+      })
+      process.exit = exitSpy as unknown as typeof process.exit
+
+      // when / then
+      try {
+        await messageCommand.parseAsync(['send', 'chat-123', 'replying', '--reply-to', '999'], { from: 'user' })
+      } catch {
+        // process.exit stub throws to abort the action
+      }
+
+      expect(mockSendMessage).not.toHaveBeenCalled()
+      expect(exitSpy).toHaveBeenCalled()
+    })
   })
 
   describe('mark-read', () => {

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

@@ -6,6 +6,7 @@ import { Command } from 'commander'
 import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 
+import type { KakaoMessage, KakaoReplyTarget } from '../types'
 import { withKakaoClient } from './shared'
 
 async function listAction(
@@ -26,16 +27,45 @@ async function listAction(
 async function sendAction(
   chatId: string,
   text: string,
-  options: { account?: string; pretty?: boolean },
+  options: { account?: string; pretty?: boolean; replyTo?: string },
 ): Promise<void> {
   try {
-    const result = await withKakaoClient(options, (client) => client.sendMessage(chatId, text))
+    const result = await withKakaoClient(options, async (client) => {
+      if (options.replyTo === undefined) {
+        return client.sendMessage(chatId, text)
+      }
+
+      const target = await resolveReplyTarget(client, chatId, options.replyTo)
+      return client.sendMessage(chatId, text, { replyTo: target })
+    })
     console.log(formatOutput(result, options.pretty))
   } catch (error) {
     handleError(error as Error)
   }
 }
 
+// A reply attachment needs the source message's author, text, and type — not
+// just its log_id — so we look it up in the chat's recent history.
+async function resolveReplyTarget(
+  client: {
+    getMessages: (chatId: string, opts: { count: number }) => Promise<KakaoMessage[]>
+  },
+  chatId: string,
+  logId: string,
+): Promise<KakaoReplyTarget> {
+  const messages = await client.getMessages(chatId, { count: 100 })
+  const source = messages.find((m) => m.log_id === logId)
+  if (!source) {
+    throw new Error(`Reply target log-id ${logId} not found in the latest 100 messages of chat ${chatId}`)
+  }
+  return {
+    log_id: source.log_id,
+    author_id: source.author_id,
+    message: source.message,
+    type: source.type,
+  }
+}
+
 type UploadKind = 'auto' | 'photo' | 'video' | 'audio' | 'file' | 'multi'
 
 async function uploadAction(
@@ -122,6 +152,7 @@ export const messageCommand = new Command('message')
       .argument('<chat-id>', 'Chat room ID')
       .argument('<text>', 'Message text')
       .option('--account <id>', 'Use a specific KakaoTalk account')
+      .option('--reply-to <log-id>', 'Send as a quoted reply to this message log ID')
       .option('--pretty', 'Pretty print JSON output')
       .action(sendAction),
   )

package/src/platforms/kakaotalk/index.ts

@@ -20,6 +20,8 @@ export type {
   KakaoMultiPhotoExtra,
   KakaoPhotoExtra,
   KakaoProfile,
+  KakaoReplyExtra,
+  KakaoReplyTarget,
   KakaoSendResult,
   KakaoTalkListenerEventMap,
   KakaoTalkPushEmoticonEvent,

package/src/platforms/kakaotalk/protocol/session.ts

@@ -1,6 +1,6 @@
 import { Binary, Long } from 'bson'
 
-import type { KakaoDeviceType } from '../types'
+import { KAKAO_MESSAGE_TYPE, type KakaoDeviceType } from '../types'
 import {
   BOOKING_HOST,
   BOOKING_PORT,
@@ -126,6 +126,20 @@ export class LocoSession {
     })
   }
 
+  // Quoted reply — a WRITE with message_type 26 (REPLY) whose `extra` JSON
+  // carries the source-message reference. The reply semantics ride entirely on
+  // `type` + `extra`; no extra top-level WRITE fields are needed.
+  async sendReply(chatId: Long, text: string, extra: Record<string, unknown>): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('WRITE', {
+      chatId,
+      msg: text,
+      type: KAKAO_MESSAGE_TYPE.REPLY,
+      noSeen: false,
+      extra: JSON.stringify(extra),
+    })
+  }
+
   // Sends a WRITE with non-text message_type plus the JSON-stringified `extra`
   // payload that KakaoTalk clients render as the attachment (photo, file, etc).
   // See types.ts → KakaoPhotoExtra / KakaoFileExtra for the per-type shape.

package/src/platforms/kakaotalk/types.ts

@@ -126,6 +126,7 @@ export const KAKAO_MESSAGE_TYPE = {
   VIDEO: 3,
   AUDIO: 5,
   FILE: 18,
+  REPLY: 26,
   MULTIPHOTO: 27,
 } as const
 
@@ -176,6 +177,29 @@ export interface KakaoMultiPhotoExtra {
   expire?: number
 }
 
+// REPLY (type 26) extra. Field names verified against storycraft/node-kakao
+// (src/chat/attachment/reply.ts) and jhleekr/kakao.py: `Id` fields are
+// camelCase (src_logId, NOT src_log_id), and src_mentions/mentions are
+// required even when empty.
+export interface KakaoReplyExtra {
+  attach_only: boolean
+  attach_type: number
+  src_logId: string
+  src_userId: number
+  src_message: string
+  src_type: number
+  src_mentions: unknown[]
+  mentions: unknown[]
+  src_linkId?: string
+}
+
+export interface KakaoReplyTarget {
+  log_id: string
+  author_id: number
+  message: string
+  type: number
+}
+
 export interface KakaoMarkReadResult {
   success: boolean
   status_code: number

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

@@ -1,6 +1,7 @@
 import { Command } from 'commander'
 
 import { handleError } from '@/shared/utils/error-handler'
+import { isInteractive } from '@/shared/utils/interactive'
 import { formatOutput } from '@/shared/utils/output'
 import { displayQR } from '@/shared/utils/qr'
 import { info } from '@/shared/utils/stderr'
@@ -9,10 +10,6 @@ import { LineClient } from '../client'
 import { LineCredentialManager } from '../credential-manager'
 import type { LineDevice } from '../types'
 
-function isInteractiveSession(): boolean {
-  return Boolean(process.stdin.isTTY && process.stdout.isTTY)
-}
-
 function getDefaultDevice(): LineDevice {
   return 'ANDROIDSECONDARY'
 }
@@ -28,7 +25,7 @@ async function loginAction(options: {
     const credManager = new LineCredentialManager()
     const client = new LineClient(credManager)
     const device: LineDevice = (options.device as LineDevice | undefined) ?? getDefaultDevice()
-    const interactive = isInteractiveSession()
+    const interactive = isInteractive()
 
     if (options.token) {
       const now = new Date().toISOString()

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

@@ -2,6 +2,7 @@ import { Writable } from 'node:stream'
 
 import { Command } from 'commander'
 
+import { isInteractive } from '@/shared/utils/interactive'
 import { info, error as stderrError } from '@/shared/utils/stderr'
 
 import { handleError } from '../../../shared/utils/error-handler'
@@ -57,10 +58,6 @@ function parseApiId(apiId?: string): number | undefined {
   return parsed
 }
 
-function isInteractiveSession(): boolean {
-  return Boolean(process.stdin.isTTY && process.stdout.isTTY)
-}
-
 async function promptLine(message: string): Promise<string | undefined> {
   const { createInterface } = await import('node:readline/promises')
   const rl = createInterface({
@@ -107,7 +104,7 @@ async function promptHidden(message: string): Promise<string | undefined> {
 }
 
 function shouldUseInteractivePrompts(): boolean {
-  return isInteractiveSession()
+  return isInteractive()
 }
 
 async function fillMissingBootstrappingInputs(
@@ -168,7 +165,7 @@ async function fillMissingBootstrappingInputs(
   }
 
   if (!resolved.apiHash && !existing?.api_hash) {
-    if (!isInteractiveSession()) {
+    if (!isInteractive()) {
       console.log(formatOutput({ error: 'missing_credentials', message: 'Provide --api-hash flag.' }, options.pretty))
       process.exit(1)
     }
@@ -176,7 +173,7 @@ async function fillMissingBootstrappingInputs(
   }
 
   if (!existing && !resolved.phone) {
-    if (!isInteractiveSession()) {
+    if (!isInteractive()) {
       console.log(formatOutput({ next_action: 'provide_phone', message: 'Provide --phone flag.' }, options.pretty))
       process.exit(0)
     }
@@ -288,7 +285,7 @@ export async function promptNextLoginInput(
   result: { next_action?: string },
   options: AuthOptions,
 ): Promise<AuthOptions | null> {
-  if (!isInteractiveSession() && result.next_action) {
+  if (!isInteractive() && result.next_action) {
     return null
   }
 

package/src/platforms/webex/commands/auth.test.ts

@@ -7,11 +7,19 @@ import { WebexTokenExtractor } from '../token-extractor'
 import { WebexError } from '../types'
 import { extractAction, loginAction, logoutAction, statusAction } from './auth'
 
+class ProcessExit extends Error {
+  constructor(readonly code?: string | number | null) {
+    super(`process.exit(${code})`)
+  }
+}
+
 describe('auth commands', () => {
   let consoleSpy: ReturnType<typeof spyOn>
   let consoleErrorSpy: ReturnType<typeof spyOn>
   let execSpy: ReturnType<typeof spyOn>
   const protoSpies: ReturnType<typeof spyOn>[] = []
+  let originalStdinTTY: boolean | undefined
+  let originalStdoutTTY: boolean | undefined
   const mockPerson = {
     id: 'person-1',
     displayName: 'Test User',
@@ -27,10 +35,19 @@ describe('auth commands', () => {
     return s
   }
 
+  function setTTY(value: boolean | undefined): void {
+    Object.defineProperty(process.stdin, 'isTTY', { value, writable: true, configurable: true })
+    Object.defineProperty(process.stdout, 'isTTY', { value, writable: true, configurable: true })
+  }
+
   beforeEach(() => {
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
     consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
     execSpy = spyOn(childProcess, 'exec').mockImplementation((() => {}) as any)
+    originalStdinTTY = process.stdin.isTTY
+    originalStdoutTTY = process.stdout.isTTY
+    // Default to interactive TTY for existing tests; non-interactive tests override.
+    setTTY(true)
   })
 
   afterEach(() => {
@@ -39,6 +56,12 @@ describe('auth commands', () => {
     execSpy.mockRestore()
     for (const s of protoSpies) s.mockRestore()
     protoSpies.length = 0
+    setTTY(originalStdinTTY)
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalStdoutTTY,
+      writable: true,
+      configurable: true,
+    })
   })
 
   describe('loginAction with --token', () => {
@@ -151,6 +174,143 @@ describe('auth commands', () => {
     })
   })
 
+  describe('loginAction non-interactive (no TTY)', () => {
+    const device = {
+      deviceCode: 'webex-device-code-abc123',
+      userCode: 'USER-CODE',
+      verificationUri: 'https://webex.com/verify',
+      verificationUriComplete: 'https://webex.com/verify?user_code=USER-CODE',
+      expiresIn: 300,
+      interval: 1,
+    }
+
+    it('first call (no --device-code): requests device code and returns it in JSON', async () => {
+      setTTY(false)
+      const requestSpy = protoSpy(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue(device)
+      const exchangeSpy = protoSpy(WebexCredentialManager.prototype, 'exchangeDeviceCode')
+      const pollSpy = protoSpy(WebexCredentialManager.prototype, 'pollDeviceToken')
+      const exitSpy = protoSpy(process, 'exit').mockImplementation(() => undefined as never)
+
+      await loginAction({ pretty: false })
+
+      expect(requestSpy).toHaveBeenCalled()
+      expect(exchangeSpy).not.toHaveBeenCalled()
+      expect(pollSpy).not.toHaveBeenCalled()
+
+      const lastCall = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.next_action).toBe('authorize_in_browser')
+      expect(output.verification_uri).toBe(device.verificationUri)
+      expect(output.verification_uri_complete).toBe(device.verificationUriComplete)
+      expect(output.user_code).toBe(device.userCode)
+      expect(output.device_code).toBe(device.deviceCode)
+      expect(output.message).toContain('--device-code')
+      expect(exitSpy).toHaveBeenCalledWith(0)
+    })
+
+    it('does not open a browser on the first non-interactive call', async () => {
+      setTTY(false)
+      protoSpy(WebexCredentialManager.prototype, 'requestDeviceCode').mockResolvedValue(device)
+      protoSpy(process, 'exit').mockImplementation(() => undefined as never)
+
+      await loginAction({ pretty: false })
+
+      expect(execSpy).not.toHaveBeenCalled()
+    })
+
+    it('second call (--device-code, pending): returns still_pending and echoes back the device_code', async () => {
+      setTTY(false)
+      protoSpy(WebexCredentialManager.prototype, 'exchangeDeviceCode').mockResolvedValue({ status: 'pending' })
+      const requestSpy = protoSpy(WebexCredentialManager.prototype, 'requestDeviceCode')
+      const exitSpy = protoSpy(process, 'exit').mockImplementation(() => undefined as never)
+
+      await loginAction({ deviceCode: 'webex-device-code-abc123', pretty: false })
+
+      expect(requestSpy).not.toHaveBeenCalled()
+
+      const lastCall = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.next_action).toBe('still_pending')
+      expect(output.device_code).toBe('webex-device-code-abc123')
+      expect(exitSpy).toHaveBeenCalledWith(0)
+    })
+
+    it('second call (--device-code, success): saves token and returns authenticated=true', async () => {
+      setTTY(false)
+      const exchangeSpy = protoSpy(WebexCredentialManager.prototype, 'exchangeDeviceCode').mockResolvedValue({
+        status: 'success',
+        config: { accessToken: 'at', refreshToken: 'rt', expiresAt: Date.now() + 3_600_000 },
+      })
+      const saveConfigSpy = protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+
+      await loginAction({
+        deviceCode: 'webex-device-code-abc123',
+        clientId: 'my-id',
+        clientSecret: 'my-secret',
+        pretty: false,
+      })
+
+      expect(exchangeSpy).toHaveBeenCalledWith('webex-device-code-abc123', 'my-id', 'my-secret')
+      const savedConfig = saveConfigSpy.mock.calls[0][0] as { tokenType: string; clientId: string }
+      expect(savedConfig.tokenType).toBe('oauth')
+      expect(savedConfig.clientId).toBe('my-id')
+
+      const lastCall = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.authenticated).toBe(true)
+      expect(output.user.displayName).toBe('Test User')
+    })
+
+    it('second call (--device-code, expired): returns next_action=restart, exits 1', async () => {
+      setTTY(false)
+      protoSpy(WebexCredentialManager.prototype, 'exchangeDeviceCode').mockResolvedValue({ status: 'expired' })
+      const exitSpy = protoSpy(process, 'exit').mockImplementation(() => undefined as never)
+
+      await loginAction({ deviceCode: 'webex-device-code-abc123', pretty: false })
+
+      const lastCall = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.next_action).toBe('restart')
+      expect(output.error).toContain('expired')
+      expect(exitSpy).toHaveBeenCalledWith(1)
+    })
+
+    it('--device-code works even with a TTY (interactive sessions can also resume)', async () => {
+      setTTY(true)
+      const exchangeSpy = protoSpy(WebexCredentialManager.prototype, 'exchangeDeviceCode').mockResolvedValue({
+        status: 'success',
+        config: { accessToken: 'at', refreshToken: 'rt', expiresAt: Date.now() + 3_600_000 },
+      })
+      const requestSpy = protoSpy(WebexCredentialManager.prototype, 'requestDeviceCode')
+      const pollSpy = protoSpy(WebexCredentialManager.prototype, 'pollDeviceToken')
+      protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+
+      await loginAction({ deviceCode: 'webex-device-code-abc123', pretty: false })
+
+      expect(exchangeSpy).toHaveBeenCalled()
+      expect(requestSpy).not.toHaveBeenCalled()
+      expect(pollSpy).not.toHaveBeenCalled()
+    })
+
+    it('still allows --token login when non-interactive (bot/PAT path)', async () => {
+      setTTY(false)
+      protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
+      protoSpy(WebexClient.prototype, 'testAuth').mockResolvedValue(mockPerson)
+      protoSpy(WebexCredentialManager.prototype, 'saveConfig').mockResolvedValue(undefined)
+
+      await loginAction({ token: 'bot-token-123', pretty: false })
+
+      const lastCall = consoleSpy.mock.calls[consoleSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.authenticated).toBe(true)
+      expect(output.user.displayName).toBe('Test User')
+    })
+  })
+
   describe('statusAction', () => {
     it('shows authenticated status when token is valid', async () => {
       protoSpy(WebexCredentialManager.prototype, 'loadConfig').mockResolvedValue(null)
@@ -287,15 +447,17 @@ describe('auth commands', () => {
       protoSpy(WebexCredentialManager.prototype, 'refreshToken').mockResolvedValue(null)
       protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
       protoSpy(WebexClient.prototype, 'testAuth').mockRejectedValue(new Error('Network error'))
-      protoSpy(process, 'exit').mockImplementation(() => undefined as never)
+      const stderrWriteSpy = protoSpy(process.stderr, 'write').mockImplementation(() => true)
+      const exitSpy = protoSpy(process, 'exit').mockImplementation((code?: string | number | null) => {
+        throw new ProcessExit(code)
+      })
 
-      await extractAction({ pretty: false })
+      await expect(extractAction({ pretty: false })).rejects.toThrow(ProcessExit)
 
-      const lastCall = consoleErrorSpy.mock.calls[consoleErrorSpy.mock.calls.length - 1]?.[0] as string | undefined
-      if (lastCall) {
-        const output = JSON.parse(lastCall)
-        expect(output.error).toContain('Network error')
-      }
+      const lastCall = stderrWriteSpy.mock.calls[stderrWriteSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.error).toContain('Network error')
+      expect(exitSpy).toHaveBeenCalledWith(1)
     })
 
     it('rethrows non-expiry auth errors', async () => {
@@ -305,15 +467,17 @@ describe('auth commands', () => {
       })
       protoSpy(WebexClient.prototype, 'login').mockResolvedValue(new WebexClient())
       protoSpy(WebexClient.prototype, 'testAuth').mockRejectedValue(new Error('Network error'))
-      protoSpy(process, 'exit').mockImplementation(() => undefined as never)
+      const stderrWriteSpy = protoSpy(process.stderr, 'write').mockImplementation(() => true)
+      const exitSpy = protoSpy(process, 'exit').mockImplementation((code?: string | number | null) => {
+        throw new ProcessExit(code)
+      })
 
-      await extractAction({ pretty: false })
+      await expect(extractAction({ pretty: false })).rejects.toThrow(ProcessExit)
 
-      const lastCall = consoleErrorSpy.mock.calls[consoleErrorSpy.mock.calls.length - 1]?.[0] as string | undefined
-      if (lastCall) {
-        const output = JSON.parse(lastCall)
-        expect(output.error).toContain('Network error')
-      }
+      const lastCall = stderrWriteSpy.mock.calls[stderrWriteSpy.mock.calls.length - 1][0] as string
+      const output = JSON.parse(lastCall)
+      expect(output.error).toContain('Network error')
+      expect(exitSpy).toHaveBeenCalledWith(1)
     })
 
     it('outputs no token found when extract returns null', async () => {