agent-messenger 2.23.6 → 2.24.1

package/src/shared/chromium/cookie-reader.ts

@@ -1,9 +1,8 @@
 import { copyFileSync, existsSync, rmSync } from 'node:fs'
-import { createRequire } from 'node:module'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-const require = createRequire(import.meta.url)
+import { openReadonlyDatabase } from '@/shared/sqlite'
 
 /**
  * Reads Chromium SQLite cookie databases with Bun/Node dual-runtime support.
@@ -70,24 +69,7 @@ export class ChromiumCookieReader {
     params: unknown[] | undefined,
     mode: 'all' | 'first',
   ): T[] | T | null {
-    if (typeof globalThis.Bun !== 'undefined') {
-      const { Database } = require('bun:sqlite')
-      const db = new Database(tempPath, { readonly: true })
-
-      try {
-        const stmt = db.query(sql)
-        if (mode === 'all') {
-          return (params ? stmt.all(...params) : stmt.all()) as T[]
-        }
-
-        return (params ? stmt.get(...params) : stmt.get()) as T | null
-      } finally {
-        db.close()
-      }
-    }
-
-    const Database = require('better-sqlite3')
-    const db = new Database(tempPath, { readonly: true })
+    const db = openReadonlyDatabase(tempPath)
 
     try {
       const stmt = db.prepare(sql)
@@ -95,7 +77,8 @@ export class ChromiumCookieReader {
         return (params ? stmt.all(...params) : stmt.all()) as T[]
       }
 
-      return (params ? stmt.get(...params) : stmt.get()) as T | null
+      const row = params ? stmt.get(...params) : stmt.get()
+      return (row ?? null) as T | null
     } finally {
       db.close()
     }

package/src/shared/sqlite.ts

@@ -0,0 +1,61 @@
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
+
+export interface ReadonlyStatement {
+  get(...params: unknown[]): unknown
+  all(...params: unknown[]): unknown[]
+}
+
+export interface ReadonlyDatabase {
+  prepare(sql: string): ReadonlyStatement
+  close(): void
+}
+
+type ReadonlyDatabaseConstructor = new (path: string, options: { readOnly: boolean }) => ReadonlyDatabase
+
+// Uses the runtime's built-in driver (bun:sqlite on Bun, node:sqlite on Node >= 22.13)
+// to avoid a native addon dependency.
+//
+// Runtime quirks callers must respect (both drivers behave this way):
+// - BLOB columns are returned as Uint8Array, not Buffer. Wrap with Buffer.from()
+//   before any Buffer-specific call (e.g. .toString('utf8'), node:crypto helpers).
+// - node:sqlite throws ERR_OUT_OF_RANGE when reading an INTEGER above
+//   Number.MAX_SAFE_INTEGER, so never SELECT raw microsecond timestamps such as
+//   Chromium's *_utc columns; use them only in WHERE / ORDER BY clauses.
+export function openReadonlyDatabase(path: string): ReadonlyDatabase {
+  if (typeof globalThis.Bun !== 'undefined') {
+    const { Database } = require('bun:sqlite')
+    return new Database(path, { readonly: true }) as ReadonlyDatabase
+  }
+
+  let DatabaseSync: ReadonlyDatabaseConstructor
+  // node:sqlite emits a one-time ExperimentalWarning to stderr on load
+  // (Node < 24.15) that clutters the CLI's output. Suppress just that warning
+  // while loading the module, then restore the original handler.
+  const originalEmitWarning = process.emitWarning
+  const filteredEmitWarning = (...args: unknown[]): void => {
+    const [warning, second] = args
+    const name =
+      warning instanceof Error
+        ? warning.name
+        : typeof second === 'string'
+          ? second
+          : (second as { type?: string } | undefined)?.type
+    const message = warning instanceof Error ? warning.message : String(warning)
+    if (name === 'ExperimentalWarning' && message.includes('SQLite')) return
+    ;(originalEmitWarning as (...forwarded: unknown[]) => void).apply(process, args)
+  }
+  process.emitWarning = filteredEmitWarning as typeof process.emitWarning
+  try {
+    DatabaseSync = require('node:sqlite').DatabaseSync
+  } catch {
+    throw new Error(
+      'SQLite support requires Node.js >= 22.13.0 (the built-in node:sqlite module) or Bun. Please upgrade Node.js.',
+    )
+  } finally {
+    process.emitWarning = originalEmitWarning
+  }
+
+  return new DatabaseSync(path, { readOnly: true })
+}

package/src/vendor/linejs/base/request/mod.js

@@ -158,7 +158,7 @@ const square = [
       throw new InternalError("RequestError", `Request internal failed, ${methodName}(${path}) -> ` + JSON.stringify(res.data.e), res.data.e);
     }
     if (hasError && !isRefresh) {
-      if (res.data.e.code === "NOT_AUTHORIZED_DEVICE") {
+      if (res.data.e && res.data.e.code === "NOT_AUTHORIZED_DEVICE") {
         delete this.client.authToken;
         this.client.emit("end", this.client.profile);
       }

package/src/vendor/linejs/base/request/mod.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'bun:test'
+
+import { InternalError } from '../core/mod.js'
+import { RequestClient } from './mod.js'
+
+// Regression: a thrift error response can set hasError (empty res.data[0]) while
+// omitting the exception struct (res.data[1] absent), leaving res.data.e undefined.
+function createClient(readThriftResult: { data: Record<string, unknown> }) {
+  const deviceDetails = {
+    device: 'TEST',
+    appVersion: '0.0.0',
+    systemName: 'TEST',
+    systemVersion: '0.0.0',
+  }
+  const stubClient = {
+    deviceDetails,
+    endpoint: 'legy.line-apps.test',
+    authToken: 'expired-token',
+    config: { timeout: 1000 },
+    storage: { get: async () => undefined },
+    log: () => {},
+    emit: () => {},
+    fetch: async () => ({
+      headers: { get: () => null },
+      arrayBuffer: async () => new ArrayBuffer(0),
+    }),
+    thrift: {
+      writeThrift: () => new Uint8Array(),
+      readThrift: () => readThriftResult,
+      rename_data: () => {},
+    },
+  }
+
+  return new RequestClient(stubClient as never)
+}
+
+describe('RequestClient.requestCore error handling', () => {
+  it('throws a clean RequestError when hasError is set but no exception struct is present', async () => {
+    // given: an error response with an empty success slot and no exception struct
+    const client = createClient({ data: { 0: undefined, someField: 1 } })
+
+    // when / then: the error branch must throw InternalError, not a TypeError
+    let thrown: unknown
+    try {
+      await client.requestCore('/S3', [], 'testMethod', 3)
+    } catch (error) {
+      thrown = error
+    }
+
+    expect(thrown).toBeInstanceOf(InternalError)
+    expect((thrown as InternalError).type).toBe('RequestError')
+    expect(thrown).not.toBeInstanceOf(TypeError)
+  })
+})