agent-messenger 2.15.1 → 2.17.0

package/src/platforms/kakaotalk/client.ts

@@ -7,17 +7,23 @@ import { Long } from 'bson'
 import { getConfigDir } from '@/shared/utils/config-dir'
 import { warn } from '@/shared/utils/stderr'
 
+import { type AttachmentInput, type ResolvedAttachment, planAttachments } from './attachment-router'
+import { detectImageDimensions } from './image-meta'
+import { sha1Hex } from './media-upload'
 import { LANG, PC_OS_NAME, getLocoDeviceConfig } from './protocol/config'
+import { uploadMediaToLoco, uploadMultiMediaEntry } from './protocol/media-uploader'
 import { LocoSession } from './protocol/session'
 import type { ChatListResponse, LocoPacket, LoginListResponse, SyncState } from './protocol/types'
-import type {
-  KakaoChat,
-  KakaoDeviceType,
-  KakaoMarkReadResult,
-  KakaoMember,
-  KakaoMessage,
-  KakaoProfile,
-  KakaoSendResult,
+import {
+  KAKAO_MESSAGE_TYPE,
+  type KakaoChat,
+  type KakaoDeviceType,
+  type KakaoMarkReadResult,
+  type KakaoMember,
+  type KakaoMessage,
+  type KakaoMultiPhotoExtra,
+  type KakaoProfile,
+  type KakaoSendResult,
 } from './types'
 
 export type KakaoSessionEvent =
@@ -895,6 +901,307 @@ export class KakaoTalkClient {
     })
   }
 
+  async sendAttachment(
+    chatId: string,
+    data: Uint8Array | Buffer,
+    filename: string,
+    mimeType?: string,
+  ): Promise<KakaoSendResult>
+  async sendAttachment(chatId: string, attachments: ReadonlyArray<AttachmentInput>): Promise<KakaoSendResult>
+  async sendAttachment(
+    chatId: string,
+    dataOrAttachments: Uint8Array | Buffer | ReadonlyArray<AttachmentInput>,
+    filename?: string,
+    mimeType?: string,
+  ): Promise<KakaoSendResult> {
+    const inputs: ReadonlyArray<AttachmentInput> = Array.isArray(dataOrAttachments)
+      ? dataOrAttachments
+      : [{ data: dataOrAttachments, filename: filename!, mime: mimeType }]
+    const plan = planAttachments(inputs)
+    switch (plan.kind) {
+      case 'single':
+        return this.dispatchSingleAttachment(chatId, plan.resolved)
+      case 'multiphoto':
+        return this.sendMultiPhoto(
+          chatId,
+          plan.items.map((it) => ({ data: it.data, filename: it.filename })),
+        )
+      case 'sequential': {
+        let last: KakaoSendResult | null = null
+        for (const r of plan.resolved) {
+          const result = await this.dispatchSingleAttachment(chatId, r)
+          if (!result.success) return result
+          last = result
+        }
+        return last!
+      }
+    }
+  }
+
+  private dispatchSingleAttachment(chatId: string, r: ResolvedAttachment): Promise<KakaoSendResult> {
+    switch (r.kind) {
+      case 'photo':
+        return this.sendPhoto(chatId, r.data, r.filename)
+      case 'video':
+        return this.sendVideo(chatId, r.data, r.filename)
+      case 'audio':
+        return this.sendAudio(chatId, r.data, r.filename)
+      case 'file':
+        return this.sendFile(chatId, r.data, r.filename, r.mime)
+    }
+  }
+
+  async sendPhoto(chatId: string, photo: Uint8Array | Buffer, filename = 'image.jpg'): Promise<KakaoSendResult> {
+    this.ensureAuth()
+    const data = photo instanceof Uint8Array ? photo : new Uint8Array(photo)
+    const dim = detectImageDimensions(data)
+    const checksum = await sha1Hex(data)
+    const ext = filename.includes('.') ? filename.split('.').pop()! : 'jpg'
+
+    return this.sendMediaViaLoco({
+      chatId,
+      data,
+      msgType: KAKAO_MESSAGE_TYPE.PHOTO,
+      filename,
+      checksum,
+      extension: ext,
+      width: dim.width,
+      height: dim.height,
+      errorCode: 'send_photo_failed',
+    })
+  }
+
+  async sendVideo(chatId: string, video: Uint8Array | Buffer, filename = 'video.mp4'): Promise<KakaoSendResult> {
+    this.ensureAuth()
+    const data = video instanceof Uint8Array ? video : new Uint8Array(video)
+    const checksum = await sha1Hex(data)
+    const ext = filename.includes('.') ? filename.split('.').pop()! : 'mp4'
+
+    return this.sendMediaViaLoco({
+      chatId,
+      data,
+      msgType: KAKAO_MESSAGE_TYPE.VIDEO,
+      filename,
+      checksum,
+      extension: ext,
+      errorCode: 'send_video_failed',
+    })
+  }
+
+  async sendAudio(chatId: string, audio: Uint8Array | Buffer, filename = 'audio.m4a'): Promise<KakaoSendResult> {
+    this.ensureAuth()
+    const data = audio instanceof Uint8Array ? audio : new Uint8Array(audio)
+    const checksum = await sha1Hex(data)
+    const ext = filename.includes('.') ? filename.split('.').pop()! : 'm4a'
+
+    return this.sendMediaViaLoco({
+      chatId,
+      data,
+      msgType: KAKAO_MESSAGE_TYPE.AUDIO,
+      filename,
+      checksum,
+      extension: ext,
+      errorCode: 'send_audio_failed',
+    })
+  }
+
+  async sendFile(
+    chatId: string,
+    file: Uint8Array | Buffer,
+    filename: string,
+    mimeType = 'application/octet-stream',
+  ): Promise<KakaoSendResult> {
+    void mimeType
+    this.ensureAuth()
+    const data = file instanceof Uint8Array ? file : new Uint8Array(file)
+    const checksum = await sha1Hex(data)
+    const ext = filename.includes('.') ? filename.split('.').pop()! : ''
+
+    return this.sendMediaViaLoco({
+      chatId,
+      data,
+      msgType: KAKAO_MESSAGE_TYPE.FILE,
+      filename,
+      checksum,
+      extension: ext,
+      errorCode: 'send_file_failed',
+    })
+  }
+
+  async sendMultiPhoto(
+    chatId: string,
+    photos: Array<{ data: Uint8Array | Buffer; filename?: string }>,
+  ): Promise<KakaoSendResult> {
+    this.ensureAuth()
+    if (photos.length < 2) {
+      throw new KakaoTalkError(
+        'sendMultiPhoto requires at least 2 photos; use sendPhoto for a single image',
+        'send_multi_photo_failed',
+      )
+    }
+
+    const prepared = await Promise.all(
+      photos.map(async (p, i) => {
+        const bytes = p.data instanceof Uint8Array ? p.data : new Uint8Array(p.data)
+        const filename = p.filename ?? `image-${i + 1}.jpg`
+        const dim = detectImageDimensions(bytes)
+        const checksum = (await sha1Hex(bytes)).toLowerCase()
+        const ext = filename.includes('.') ? filename.split('.').pop()! : 'jpg'
+        return { bytes, filename, dim, checksum, ext }
+      }),
+    )
+
+    const parsedChatId = parseChatId(chatId)
+
+    return this.executeWithReconnect(async ({ session }) => {
+      try {
+        const mshipResp = await session.shipMultiMedia(
+          parsedChatId,
+          KAKAO_MESSAGE_TYPE.MULTIPHOTO,
+          prepared.map((p) => p.bytes.byteLength),
+          prepared.map((p) => p.checksum),
+          prepared.map((p) => p.ext),
+        )
+
+        if (mshipResp.statusCode !== 0) {
+          throw new KakaoTalkError(`MSHIP rejected (status ${mshipResp.statusCode})`, 'send_multi_photo_failed')
+        }
+
+        const body = mshipResp.body as Record<string, unknown>
+        const kl = body.kl as string[] | undefined
+        const vhl = body.vhl as string[] | undefined
+        const pl = body.pl as number[] | undefined
+        if (
+          !kl ||
+          !vhl ||
+          !pl ||
+          kl.length !== prepared.length ||
+          vhl.length !== prepared.length ||
+          pl.length !== prepared.length
+        ) {
+          throw new KakaoTalkError(
+            `MSHIP response arrays do not match prepared.length=${prepared.length}: ` +
+              `kl=${kl?.length} vhl=${vhl?.length} pl=${pl?.length}`,
+            'send_multi_photo_failed',
+          )
+        }
+
+        await Promise.all(
+          prepared.map((p, i) =>
+            uploadMultiMediaEntry({
+              shipToken: kl[i]!,
+              shipHost: vhl[i]!,
+              shipPort: pl[i]!,
+              chatId: parsedChatId,
+              msgType: KAKAO_MESSAGE_TYPE.MULTIPHOTO,
+              userId: this.userId!,
+              filename: p.filename,
+              data: p.bytes,
+              width: p.dim.width,
+              height: p.dim.height,
+              deviceType: this.deviceType,
+            }),
+          ),
+        )
+
+        const extra: KakaoMultiPhotoExtra = {
+          kl,
+          wl: prepared.map((p) => p.dim.width),
+          hl: prepared.map((p) => p.dim.height),
+          mtl: prepared.map((p) => p.dim.mimeType),
+          sl: prepared.map((p) => p.bytes.byteLength),
+          csl: prepared.map((p) => p.checksum),
+          cmtl: prepared.map(() => ''),
+        }
+
+        const forwardResp = await session.forwardChat(
+          parsedChatId,
+          KAKAO_MESSAGE_TYPE.MULTIPHOTO,
+          extra as unknown as Record<string, unknown>,
+        )
+
+        return {
+          success: forwardResp.statusCode === 0,
+          status_code: forwardResp.statusCode,
+          chat_id: chatId,
+          log_id: longToString((forwardResp.body as Record<string, unknown>).logId),
+          sent_at: ((forwardResp.body as Record<string, unknown>).sendAt as number | undefined) ?? 0,
+        }
+      } catch (error) {
+        throw wrapError(error, 'send_multi_photo_failed')
+      }
+    })
+  }
+
+  private async sendMediaViaLoco(opts: {
+    chatId: string
+    data: Uint8Array
+    msgType: number
+    filename: string
+    checksum: string
+    extension: string
+    width?: number
+    height?: number
+    errorCode: string
+  }): Promise<KakaoSendResult> {
+    const parsedChatId = parseChatId(opts.chatId)
+    return this.executeWithReconnect(async ({ session }) => {
+      try {
+        const shipResp = await session.shipMedia(
+          parsedChatId,
+          opts.msgType,
+          opts.data.byteLength,
+          opts.checksum,
+          opts.extension,
+        )
+
+        if (shipResp.statusCode !== 0) {
+          throw new KakaoTalkError(`SHIP rejected (status ${shipResp.statusCode})`, opts.errorCode)
+        }
+
+        const body = shipResp.body as Record<string, unknown>
+        const shipToken = body.k as string | undefined
+        const shipHost = body.vh as string | undefined
+        const shipPort = body.p as number | undefined
+
+        if (typeof shipToken !== 'string' || typeof shipHost !== 'string' || typeof shipPort !== 'number') {
+          throw new KakaoTalkError(
+            `SHIP response missing fields: k=${shipToken} vh=${shipHost} p=${shipPort}`,
+            opts.errorCode,
+          )
+        }
+
+        const uploadRes = await uploadMediaToLoco({
+          shipToken,
+          shipHost,
+          shipPort,
+          chatId: parsedChatId,
+          msgType: opts.msgType,
+          userId: this.userId!,
+          filename: opts.filename,
+          data: opts.data,
+          width: opts.width,
+          height: opts.height,
+          deviceType: this.deviceType,
+        })
+
+        const completeBody = uploadRes.completePacket?.body as Record<string, unknown> | undefined
+        const chatLog = completeBody?.chatLog as Record<string, unknown> | undefined
+        const logId = chatLog?.logId
+
+        return {
+          success: uploadRes.completePacket !== null && uploadRes.postStatusCode === 0,
+          status_code: uploadRes.postStatusCode,
+          chat_id: opts.chatId,
+          log_id: longToString(logId),
+          sent_at: (chatLog?.sendAt as number | undefined) ?? 0,
+        }
+      } catch (error) {
+        throw wrapError(error, opts.errorCode)
+      }
+    })
+  }
+
   /**
    * Advance the read watermark for `chatId` up to and including `logId`.
    * The caller decides open vs normal: pass `opts.linkId` for open chats

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

@@ -1,3 +1,6 @@
+import { readFileSync } from 'node:fs'
+import { basename, resolve } from 'node:path'
+
 import { Command } from 'commander'
 
 import { handleError } from '@/shared/utils/error-handler'
@@ -33,6 +36,56 @@ async function sendAction(
   }
 }
 
+type UploadKind = 'auto' | 'photo' | 'video' | 'audio' | 'file' | 'multi'
+
+async function uploadAction(
+  chatId: string,
+  filePaths: string[],
+  options: { account?: string; pretty?: boolean; as?: UploadKind; mime?: string },
+): Promise<void> {
+  try {
+    const kind: UploadKind = options.as ?? (filePaths.length > 1 ? 'multi' : 'auto')
+
+    const result = await withKakaoClient(options, async (client) => {
+      if (kind === 'multi') {
+        if (filePaths.length < 2) {
+          throw new Error('--as=multi requires 2 or more files')
+        }
+        return client.sendMultiPhoto(
+          chatId,
+          filePaths.map((p) => ({ data: readFileSync(resolve(p)), filename: basename(p) })),
+        )
+      }
+
+      if (filePaths.length !== 1) {
+        throw new Error(`--as=${kind} accepts exactly one file path`)
+      }
+      const path = resolve(filePaths[0]!)
+      const data = readFileSync(path)
+      const filename = basename(path)
+
+      switch (kind) {
+        case 'auto':
+          return client.sendAttachment(chatId, data, filename, options.mime)
+        case 'photo':
+          return client.sendPhoto(chatId, data, filename)
+        case 'video':
+          return client.sendVideo(chatId, data, filename)
+        case 'audio':
+          return client.sendAudio(chatId, data, filename)
+        case 'file':
+          return client.sendFile(chatId, data, filename, options.mime ?? 'application/octet-stream')
+      }
+    })
+    console.log(formatOutput(result, options.pretty))
+    if (!result.success) {
+      process.exit(1)
+    }
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 async function markReadAction(
   chatId: string,
   logId: string,
@@ -72,6 +125,19 @@ export const messageCommand = new Command('message')
       .option('--pretty', 'Pretty print JSON output')
       .action(sendAction),
   )
+  .addCommand(
+    new Command('upload')
+      .description(
+        'Send one or more files to a chat. MIME is sniffed from the filename (or --mime) and dispatched to the matching KakaoTalk message_type. Pass 2+ files (or --as=multi) for a multi-photo gallery.',
+      )
+      .argument('<chat-id>', 'Chat room ID')
+      .argument('<file-paths...>', 'One or more file paths')
+      .option('--account <id>', 'Use a specific KakaoTalk account')
+      .option('--as <kind>', 'Force a specific kind: auto | photo | video | audio | file | multi')
+      .option('--mime <type>', 'Override MIME type (otherwise inferred from filename)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(uploadAction),
+  )
   .addCommand(
     new Command('mark-read')
       .description('Mark messages in a chat room as read up to a given log ID')

package/src/platforms/kakaotalk/image-meta.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'bun:test'
+
+import { detectImageDimensions } from './image-meta'
+
+function buildPng(width: number, height: number, opts?: { skipTrailingMagic?: boolean }): Uint8Array {
+  const buf = new Uint8Array(24)
+  const sig = opts?.skipTrailingMagic
+    ? [0x89, 0x50, 0x4e, 0x47, 0x00, 0x00, 0x00, 0x00]
+    : [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]
+  buf.set(sig, 0)
+  const view = new DataView(buf.buffer)
+  view.setUint32(16, width, false)
+  view.setUint32(20, height, false)
+  return buf
+}
+
+function buildGif(version: '87a' | '89a' | 'XXa', width: number, height: number): Uint8Array {
+  const buf = new Uint8Array(10)
+  buf.set([0x47, 0x49, 0x46], 0)
+  if (version === '87a') buf.set([0x38, 0x37, 0x61], 3)
+  else if (version === '89a') buf.set([0x38, 0x39, 0x61], 3)
+  else buf.set([0x00, 0x00, 0x00], 3)
+  const view = new DataView(buf.buffer)
+  view.setUint16(6, width, true)
+  view.setUint16(8, height, true)
+  return buf
+}
+
+function buildJpeg(opts: {
+  width: number
+  height: number
+  prefixFillBytes?: number
+  includeStandaloneMarkers?: boolean
+}): Uint8Array {
+  const parts: number[] = [0xff, 0xd8]
+  if (opts.includeStandaloneMarkers) {
+    parts.push(0xff, 0xd0, 0xff, 0xd9)
+  }
+  for (let i = 0; i < (opts.prefixFillBytes ?? 0); i++) parts.push(0xff)
+  parts.push(0xff, 0xc0)
+  parts.push(0x00, 0x11)
+  parts.push(0x08)
+  parts.push((opts.height >> 8) & 0xff, opts.height & 0xff)
+  parts.push((opts.width >> 8) & 0xff, opts.width & 0xff)
+  for (let i = 0; i < 10; i++) parts.push(0x00)
+  return new Uint8Array(parts)
+}
+
+describe('detectImageDimensions', () => {
+  it('reads PNG dimensions when the full 8-byte signature is present', () => {
+    const dim = detectImageDimensions(buildPng(320, 240))
+    expect(dim).toEqual({ width: 320, height: 240, mimeType: 'image/png' })
+  })
+
+  it('rejects PNG-look-alikes that share only the first 4 bytes', () => {
+    expect(() => detectImageDimensions(buildPng(1, 1, { skipTrailingMagic: true }))).toThrow(/Unsupported/)
+  })
+
+  it('reads GIF87a and GIF89a dimensions', () => {
+    expect(detectImageDimensions(buildGif('87a', 100, 200))).toEqual({
+      width: 100,
+      height: 200,
+      mimeType: 'image/gif',
+    })
+    expect(detectImageDimensions(buildGif('89a', 64, 32))).toEqual({
+      width: 64,
+      height: 32,
+      mimeType: 'image/gif',
+    })
+  })
+
+  it('rejects GIF-look-alikes with the wrong version bytes', () => {
+    expect(() => detectImageDimensions(buildGif('XXa', 100, 200))).toThrow(/Unsupported/)
+  })
+
+  it('reads JPEG dimensions from a plain SOF0 marker', () => {
+    const dim = detectImageDimensions(buildJpeg({ width: 800, height: 600 }))
+    expect(dim).toEqual({ width: 800, height: 600, mimeType: 'image/jpeg' })
+  })
+
+  it('reads JPEG dimensions when 0xFF fill bytes precede the SOF marker', () => {
+    const dim = detectImageDimensions(buildJpeg({ width: 1280, height: 720, prefixFillBytes: 5 }))
+    expect(dim).toEqual({ width: 1280, height: 720, mimeType: 'image/jpeg' })
+  })
+
+  it('reads JPEG dimensions past standalone markers (RST/SOI/EOI) without desyncing', () => {
+    const dim = detectImageDimensions(buildJpeg({ width: 42, height: 99, includeStandaloneMarkers: true }))
+    expect(dim).toEqual({ width: 42, height: 99, mimeType: 'image/jpeg' })
+  })
+})

package/src/platforms/kakaotalk/image-meta.ts

@@ -0,0 +1,176 @@
+export interface ImageDimensions {
+  width: number
+  height: number
+  mimeType: string
+}
+
+// Extracts width/height/mime by reading the file's magic bytes and headers
+// directly. Avoids pulling in `image-size` or `sharp` so the SDK stays
+// dependency-light. Supports JPEG, PNG, GIF, WebP — the formats KakaoTalk
+// actually renders inline. Throws for anything else (including truncated
+// headers whose magic matches but whose length is short of the dimension
+// fields, to avoid an unhandled DataView RangeError); the caller should fall
+// back to `sendFile` (type=18) for unknown types.
+export function detectImageDimensions(buffer: Uint8Array): ImageDimensions {
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+
+  if (isPng(buffer)) {
+    if (buffer.length < 24) {
+      throw new Error('Truncated PNG: header is shorter than 24 bytes')
+    }
+    return {
+      width: view.getUint32(16, false),
+      height: view.getUint32(20, false),
+      mimeType: 'image/png',
+    }
+  }
+
+  if (isJpeg(buffer)) {
+    const dim = readJpegDimensions(buffer)
+    return { ...dim, mimeType: 'image/jpeg' }
+  }
+
+  if (isGif(buffer)) {
+    if (buffer.length < 10) {
+      throw new Error('Truncated GIF: header is shorter than 10 bytes')
+    }
+    return {
+      width: view.getUint16(6, true),
+      height: view.getUint16(8, true),
+      mimeType: 'image/gif',
+    }
+  }
+
+  if (isWebp(buffer)) {
+    if (buffer.length < 16) {
+      throw new Error('Truncated WebP: header is shorter than 16 bytes')
+    }
+    return { ...readWebpDimensions(buffer), mimeType: 'image/webp' }
+  }
+
+  throw new Error('Unsupported image format (expected JPEG, PNG, GIF, or WebP)')
+}
+
+// Full PNG signature: 89 50 4E 47 0D 0A 1A 0A — checking only the first 4 bytes
+// would let a file that happens to start with "\x89PNG" but isn't really a PNG
+// reach the dimension reader and either crash or return garbage. The trailing
+// CRLF/EOF/LF bytes pin it to a real PNG header.
+function isPng(b: Uint8Array): boolean {
+  return (
+    b[0] === 0x89 &&
+    b[1] === 0x50 &&
+    b[2] === 0x4e &&
+    b[3] === 0x47 &&
+    b[4] === 0x0d &&
+    b[5] === 0x0a &&
+    b[6] === 0x1a &&
+    b[7] === 0x0a
+  )
+}
+
+function isJpeg(b: Uint8Array): boolean {
+  return b[0] === 0xff && b[1] === 0xd8
+}
+
+// GIF signature is "GIF87a" or "GIF89a". Checking only "GIF" would match any
+// payload that starts with those three bytes (other Compuserve formats, etc.).
+function isGif(b: Uint8Array): boolean {
+  return (
+    b[0] === 0x47 &&
+    b[1] === 0x49 &&
+    b[2] === 0x46 &&
+    b[3] === 0x38 &&
+    (b[4] === 0x37 || b[4] === 0x39) &&
+    b[5] === 0x61
+  )
+}
+
+function isWebp(b: Uint8Array): boolean {
+  return (
+    b[0] === 0x52 &&
+    b[1] === 0x49 &&
+    b[2] === 0x46 &&
+    b[3] === 0x46 &&
+    b[8] === 0x57 &&
+    b[9] === 0x45 &&
+    b[10] === 0x42 &&
+    b[11] === 0x50
+  )
+}
+
+// JPEG dimensions live in an SOF (Start Of Frame) marker (0xFFC0..0xFFCF except
+// 0xFFC4, 0xFFC8, 0xFFCC which are not SOF). We scan markers until we hit one.
+//
+// The scan has to handle two JPEG quirks (ITU-T T.81 §B.1):
+//   1. Fill bytes — any number of 0xFF bytes may precede a marker, so on a
+//      0xFF byte we look at the next byte for the actual marker code and skip
+//      forward by 1 if it's another 0xFF (without trying to read a length).
+//   2. Standalone markers — SOI/EOI/RST0-7/TEM (0xFFD0..0xFFD9, 0xFF01) have
+//      no length field, so we step past them with a fixed +2 instead of
+//      reading garbage as a segment length.
+// Treating either case as a length-prefixed segment desynchronizes the scan
+// and either skips past the SOF or runs off the end of the buffer.
+function readJpegDimensions(buffer: Uint8Array): { width: number; height: number } {
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+  let i = 2
+  while (i < buffer.length - 9) {
+    if (buffer[i] !== 0xff) {
+      i++
+      continue
+    }
+    const marker = buffer[i + 1] ?? 0
+    if (marker === 0xff) {
+      i++
+      continue
+    }
+    if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+      const height = view.getUint16(i + 5, false)
+      const width = view.getUint16(i + 7, false)
+      return { width, height }
+    }
+    if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd9)) {
+      i += 2
+      continue
+    }
+    const segmentLength = view.getUint16(i + 2, false)
+    i += 2 + segmentLength
+  }
+  throw new Error('JPEG SOF marker not found')
+}
+
+// WebP supports several variants: VP8 (lossy), VP8L (lossless), VP8X (extended).
+// Dimensions live at different offsets per variant; we cover all three.
+function readWebpDimensions(buffer: Uint8Array): { width: number; height: number } {
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+  const fourCC = String.fromCharCode(buffer[12]!, buffer[13]!, buffer[14]!, buffer[15]!)
+
+  if (fourCC === 'VP8 ') {
+    if (buffer.length < 30) {
+      throw new Error('Truncated WebP VP8: header is shorter than 30 bytes')
+    }
+    const width = view.getUint16(26, true) & 0x3fff
+    const height = view.getUint16(28, true) & 0x3fff
+    return { width, height }
+  }
+  if (fourCC === 'VP8L') {
+    if (buffer.length < 25) {
+      throw new Error('Truncated WebP VP8L: header is shorter than 25 bytes')
+    }
+    const b0 = buffer[21]!
+    const b1 = buffer[22]!
+    const b2 = buffer[23]!
+    const b3 = buffer[24]!
+    const width = 1 + (((b1 & 0x3f) << 8) | b0)
+    const height = 1 + (((b3 & 0x0f) << 10) | (b2 << 2) | ((b1 & 0xc0) >> 6))
+    return { width, height }
+  }
+  if (fourCC === 'VP8X') {
+    if (buffer.length < 31) {
+      throw new Error('Truncated WebP VP8X: header is shorter than 31 bytes')
+    }
+    const width = 1 + (view.getUint32(24, true) & 0xffffff)
+    const height = 1 + (view.getUint32(27, true) & 0xffffff)
+    return { width, height }
+  }
+  throw new Error(`Unsupported WebP variant: ${fourCC}`)
+}