openzca 0.1.50 → 0.1.51

package/README.md

@@ -19,7 +19,9 @@ Or run without installing:
 npx openzca --help
 ```
 
-Requires Node.js 18+.
+Requires Node.js 22.13+.
+
+The built-in DB backend now uses Node's official `node:sqlite` module, so no extra `sqlite3` native addon is installed.
 
 ## Quick start
 

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import { spawn as spawn2 } from "child_process";
 import fsSync from "fs";
 import fs6 from "fs/promises";
@@ -214,13 +214,273 @@ async function clearCache(profileName) {
 // src/lib/db.ts
 import crypto from "crypto";
 import fs2 from "fs/promises";
+import { createRequire } from "module";
 import path2 from "path";
-import { open } from "sqlite";
-import sqlite3 from "sqlite3";
+import { Worker } from "worker_threads";
+var require2 = createRequire(import.meta.url);
+function buildDbError(error) {
+  const built = new Error(error.message);
+  built.name = error.name || "Error";
+  built.stack = error.stack ?? built.stack;
+  built.code = error.code;
+  return built;
+}
+function resolveWorkerSpec() {
+  const currentUrl = new URL(import.meta.url);
+  if (currentUrl.pathname.endsWith("/src/lib/db.ts")) {
+    return {
+      url: new URL("./db-worker.ts", currentUrl),
+      execArgv: ["--import", require2.resolve("tsx")]
+    };
+  }
+  return {
+    url: new URL("./db-worker.js", currentUrl)
+  };
+}
+var Database = class _Database {
+  #worker;
+  #closed = false;
+  #closing = false;
+  #released = false;
+  #nextId = 1;
+  #activeRequests = 0;
+  #idleTimer;
+  #closePromise;
+  #pending = /* @__PURE__ */ new Map();
+  #ready;
+  #exited;
+  #releaseConnection;
+  constructor(worker, releaseConnection) {
+    this.#worker = worker;
+    this.#releaseConnection = releaseConnection;
+    let resolveReady;
+    let rejectReady;
+    this.#ready = new Promise((resolve, reject) => {
+      resolveReady = resolve;
+      rejectReady = reject;
+    });
+    let resolveExited;
+    this.#exited = new Promise((resolve) => {
+      resolveExited = resolve;
+    });
+    const rejectPending = (error) => {
+      for (const { reject } of this.#pending.values()) {
+        reject(error);
+      }
+      this.#pending.clear();
+    };
+    worker.on("message", (message) => {
+      if (message.type === "ready") {
+        resolveReady();
+        return;
+      }
+      if (message.type === "fatal") {
+        const error = buildDbError(message.error);
+        rejectReady(error);
+        rejectPending(error);
+        return;
+      }
+      const pending = this.#pending.get(message.id);
+      if (!pending) {
+        return;
+      }
+      this.#pending.delete(message.id);
+      if (message.type === "error") {
+        pending.reject(buildDbError(message.error));
+        return;
+      }
+      pending.resolve(message.result);
+    });
+    worker.once("error", (error) => {
+      rejectReady(error);
+      rejectPending(error instanceof Error ? error : new Error(String(error)));
+    });
+    worker.once("exit", (code) => {
+      this.#closed = true;
+      this.#release();
+      resolveExited();
+      const error = new Error(
+        code === 0 ? "DB worker exited" : `DB worker exited with code ${code}`
+      );
+      if (code !== 0) {
+        rejectReady(error);
+      }
+      if (this.#pending.size > 0) {
+        rejectPending(error);
+      }
+    });
+  }
+  static async open(filename, onClosed) {
+    const { url, execArgv } = resolveWorkerSpec();
+    const worker = new Worker(url, {
+      execArgv,
+      workerData: { filename }
+    });
+    worker.unref();
+    const db = new _Database(worker, onClosed);
+    await db.#ready;
+    return db;
+  }
+  get isClosing() {
+    return this.#closing || this.#closed;
+  }
+  #release() {
+    if (this.#released) {
+      return;
+    }
+    this.#released = true;
+    this.#releaseConnection();
+  }
+  #clearIdleClose() {
+    if (this.#idleTimer) {
+      clearTimeout(this.#idleTimer);
+      this.#idleTimer = void 0;
+    }
+  }
+  #scheduleIdleClose() {
+    this.#clearIdleClose();
+    this.#idleTimer = setTimeout(() => {
+      if (this.#activeRequests === 0 && !this.#closed) {
+        void this.close().catch(() => {
+        });
+      }
+    }, 100);
+    this.#idleTimer.unref();
+  }
+  async #request(type, payload) {
+    if (this.#closed) {
+      throw new Error("DB worker is closed");
+    }
+    if (this.#closing && type !== "close") {
+      throw new Error("DB worker is closing");
+    }
+    this.#clearIdleClose();
+    this.#activeRequests += 1;
+    await this.#ready;
+    const id = this.#nextId;
+    this.#nextId += 1;
+    const request = payload === void 0 ? { id, type } : { id, type, payload };
+    const result = new Promise((resolve, reject) => {
+      this.#pending.set(id, { resolve, reject });
+    });
+    try {
+      this.#worker.postMessage(request);
+    } catch (error) {
+      this.#pending.delete(id);
+      throw error;
+    }
+    try {
+      return await result;
+    } finally {
+      this.#activeRequests -= 1;
+      if (this.#activeRequests === 0 && !this.#closed && !this.#closing) {
+        this.#scheduleIdleClose();
+      }
+    }
+  }
+  async exec(sql) {
+    await this.#request("exec", { sql });
+  }
+  async run(sql, params = []) {
+    return await this.#request("run", { sql, params });
+  }
+  async get(sql, params = []) {
+    const result = await this.#request("get", { sql, params });
+    return result ?? void 0;
+  }
+  async all(sql, params = []) {
+    return await this.#request("all", { sql, params });
+  }
+  async batch(commands, transactional = false) {
+    await this.#request("batch", { commands, transactional });
+  }
+  async close() {
+    if (this.#closed) {
+      return;
+    }
+    if (this.#closePromise) {
+      return this.#closePromise;
+    }
+    this.#closePromise = (async () => {
+      this.#closing = true;
+      this.#release();
+      this.#clearIdleClose();
+      await this.#request("close");
+      this.#closed = true;
+      await this.#exited;
+    })();
+    return this.#closePromise;
+  }
+};
 var DB_CONFIG_FILE = "db.json";
 var DB_FILENAME = "messages.sqlite";
 var connections = /* @__PURE__ */ new Map();
 var writeQueues = /* @__PURE__ */ new Map();
+var UPSERT_THREAD_SQL = `
+  INSERT INTO threads (
+    profile, scope_thread_id, raw_thread_id, thread_type, peer_id, title,
+    is_pinned, is_hidden, is_archived, raw_json, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT(profile, scope_thread_id) DO UPDATE SET
+    raw_thread_id = excluded.raw_thread_id,
+    thread_type = excluded.thread_type,
+    peer_id = COALESCE(excluded.peer_id, threads.peer_id),
+    title = COALESCE(excluded.title, threads.title),
+    is_pinned = excluded.is_pinned,
+    is_hidden = excluded.is_hidden,
+    is_archived = excluded.is_archived,
+    raw_json = COALESCE(excluded.raw_json, threads.raw_json),
+    updated_at = excluded.updated_at
+`;
+var INSERT_THREAD_MEMBER_SQL = `
+  INSERT INTO thread_members (
+    profile, scope_thread_id, user_id, display_name, zalo_name, avatar,
+    account_status, member_type, raw_json, snapshot_at_ms, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`;
+var UPSERT_MESSAGE_SQL = `
+  INSERT INTO messages (
+    profile, message_uid, scope_thread_id, raw_thread_id, thread_type,
+    msg_id, cli_msg_id, action_id, sender_id, sender_name, to_id,
+    timestamp_ms, msg_type, content_text, content_json,
+    quote_msg_id, quote_cli_msg_id, quote_owner_id, quote_text,
+    source, raw_message_json, raw_payload_json, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT(profile, message_uid) DO UPDATE SET
+    scope_thread_id = excluded.scope_thread_id,
+    raw_thread_id = excluded.raw_thread_id,
+    thread_type = excluded.thread_type,
+    msg_id = COALESCE(excluded.msg_id, messages.msg_id),
+    cli_msg_id = COALESCE(excluded.cli_msg_id, messages.cli_msg_id),
+    action_id = COALESCE(excluded.action_id, messages.action_id),
+    sender_id = COALESCE(excluded.sender_id, messages.sender_id),
+    sender_name = COALESCE(excluded.sender_name, messages.sender_name),
+    to_id = COALESCE(excluded.to_id, messages.to_id),
+    timestamp_ms = excluded.timestamp_ms,
+    msg_type = COALESCE(excluded.msg_type, messages.msg_type),
+    content_text = COALESCE(excluded.content_text, messages.content_text),
+    content_json = COALESCE(excluded.content_json, messages.content_json),
+    quote_msg_id = COALESCE(excluded.quote_msg_id, messages.quote_msg_id),
+    quote_cli_msg_id = COALESCE(excluded.quote_cli_msg_id, messages.quote_cli_msg_id),
+    quote_owner_id = COALESCE(excluded.quote_owner_id, messages.quote_owner_id),
+    quote_text = COALESCE(excluded.quote_text, messages.quote_text),
+    source = excluded.source,
+    raw_message_json = COALESCE(excluded.raw_message_json, messages.raw_message_json),
+    raw_payload_json = COALESCE(excluded.raw_payload_json, messages.raw_payload_json),
+    updated_at = excluded.updated_at
+`;
+var INSERT_MESSAGE_MEDIA_SQL = `
+  INSERT INTO message_media (
+    profile, message_uid, item_index, media_kind, media_url,
+    media_path, media_type, raw_json, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`;
+var INSERT_MESSAGE_MENTION_SQL = `
+  INSERT INTO message_mentions (
+    profile, message_uid, item_index, target_user_id, pos, len,
+    mention_type, raw_json, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`;
 function nowIso2() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -326,165 +586,21 @@ async function resolveDbPath(profile) {
   }
   return path2.isAbsolute(configured) ? configured : path2.resolve(getProfileDir(profile), configured);
 }
-async function migrateDb(db) {
-  await db.exec(`
-    PRAGMA journal_mode = WAL;
-    PRAGMA foreign_keys = ON;
-
-    CREATE TABLE IF NOT EXISTS threads (
-      profile TEXT NOT NULL,
-      scope_thread_id TEXT NOT NULL,
-      raw_thread_id TEXT NOT NULL,
-      thread_type TEXT NOT NULL,
-      peer_id TEXT,
-      title TEXT,
-      is_pinned INTEGER NOT NULL DEFAULT 0,
-      is_hidden INTEGER NOT NULL DEFAULT 0,
-      is_archived INTEGER NOT NULL DEFAULT 0,
-      raw_json TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (profile, scope_thread_id)
-    );
-
-    CREATE TABLE IF NOT EXISTS thread_members (
-      profile TEXT NOT NULL,
-      scope_thread_id TEXT NOT NULL,
-      user_id TEXT NOT NULL,
-      display_name TEXT,
-      zalo_name TEXT,
-      avatar TEXT,
-      account_status INTEGER,
-      member_type INTEGER,
-      raw_json TEXT,
-      snapshot_at_ms INTEGER NOT NULL,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (profile, scope_thread_id, user_id)
-    );
-
-    CREATE TABLE IF NOT EXISTS friends (
-      profile TEXT NOT NULL,
-      user_id TEXT NOT NULL,
-      display_name TEXT,
-      zalo_name TEXT,
-      avatar TEXT,
-      account_status INTEGER,
-      raw_json TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (profile, user_id)
-    );
-
-    CREATE TABLE IF NOT EXISTS self_profiles (
-      profile TEXT NOT NULL,
-      user_id TEXT NOT NULL,
-      display_name TEXT,
-      info_json TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (profile)
-    );
-
-    CREATE TABLE IF NOT EXISTS messages (
-      profile TEXT NOT NULL,
-      message_uid TEXT NOT NULL,
-      scope_thread_id TEXT NOT NULL,
-      raw_thread_id TEXT NOT NULL,
-      thread_type TEXT NOT NULL,
-      msg_id TEXT,
-      cli_msg_id TEXT,
-      action_id TEXT,
-      sender_id TEXT,
-      sender_name TEXT,
-      to_id TEXT,
-      timestamp_ms INTEGER NOT NULL,
-      msg_type TEXT,
-      content_text TEXT,
-      content_json TEXT,
-      quote_msg_id TEXT,
-      quote_cli_msg_id TEXT,
-      quote_owner_id TEXT,
-      quote_text TEXT,
-      source TEXT NOT NULL,
-      raw_message_json TEXT,
-      raw_payload_json TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (profile, message_uid)
-    );
-
-    CREATE TABLE IF NOT EXISTS message_media (
-      profile TEXT NOT NULL,
-      message_uid TEXT NOT NULL,
-      item_index INTEGER NOT NULL,
-      media_kind TEXT,
-      media_url TEXT,
-      media_path TEXT,
-      media_type TEXT,
-      raw_json TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (profile, message_uid, item_index)
-    );
-
-    CREATE TABLE IF NOT EXISTS message_mentions (
-      profile TEXT NOT NULL,
-      message_uid TEXT NOT NULL,
-      item_index INTEGER NOT NULL,
-      target_user_id TEXT NOT NULL,
-      pos INTEGER,
-      len INTEGER,
-      mention_type INTEGER,
-      raw_json TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (profile, message_uid, item_index)
-    );
-
-    CREATE TABLE IF NOT EXISTS sync_state (
-      profile TEXT NOT NULL,
-      scope TEXT NOT NULL,
-      scope_thread_id TEXT NOT NULL,
-      thread_type TEXT NOT NULL,
-      status TEXT NOT NULL,
-      completeness TEXT,
-      cursor TEXT,
-      last_sync_at TEXT,
-      error TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (profile, scope)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_messages_thread_time
-      ON messages (profile, scope_thread_id, timestamp_ms DESC);
-    CREATE INDEX IF NOT EXISTS idx_messages_msg_id
-      ON messages (profile, msg_id);
-    CREATE INDEX IF NOT EXISTS idx_messages_cli_msg_id
-      ON messages (profile, cli_msg_id);
-    CREATE INDEX IF NOT EXISTS idx_threads_type
-      ON threads (profile, thread_type, updated_at DESC);
-    CREATE INDEX IF NOT EXISTS idx_members_thread
-      ON thread_members (profile, scope_thread_id);
-    CREATE INDEX IF NOT EXISTS idx_friends_name
-      ON friends (profile, display_name, zalo_name, user_id);
-  `);
-}
 async function openDb(profile) {
   const filename = await resolveDbPath(profile);
   await fs2.mkdir(path2.dirname(filename), { recursive: true });
-  const db = await open({
-    filename,
-    driver: sqlite3.Database
+  return Database.open(filename, () => {
+    connections.delete(profile);
   });
-  await migrateDb(db);
-  return db;
 }
 async function getDb(profile) {
   const existing = connections.get(profile);
   if (existing) {
-    return existing;
+    const db = await existing;
+    if (!db.isClosing) {
+      return db;
+    }
+    connections.delete(profile);
   }
   const created = openDb(profile).catch((error) => {
     connections.delete(profile);
@@ -596,77 +712,48 @@ function enqueueDbWrite(profile, task) {
 async function persistThread(record) {
   const db = await getDb(record.profile);
   const now = nowIso2();
-  await db.run(
-    `
-      INSERT INTO threads (
-        profile, scope_thread_id, raw_thread_id, thread_type, peer_id, title,
-        is_pinned, is_hidden, is_archived, raw_json, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(profile, scope_thread_id) DO UPDATE SET
-        raw_thread_id = excluded.raw_thread_id,
-        thread_type = excluded.thread_type,
-        peer_id = COALESCE(excluded.peer_id, threads.peer_id),
-        title = COALESCE(excluded.title, threads.title),
-        is_pinned = excluded.is_pinned,
-        is_hidden = excluded.is_hidden,
-        is_archived = excluded.is_archived,
-        raw_json = COALESCE(excluded.raw_json, threads.raw_json),
-        updated_at = excluded.updated_at
-    `,
-    [
-      record.profile,
-      record.scopeThreadId,
-      record.rawThreadId,
-      record.threadType,
-      record.peerId ?? null,
-      record.title ?? null,
-      record.isPinned ? 1 : 0,
-      record.isHidden ? 1 : 0,
-      record.isArchived ? 1 : 0,
-      record.rawJson ?? null,
-      now,
-      now
-    ]
-  );
+  await db.run(UPSERT_THREAD_SQL, [
+    record.profile,
+    record.scopeThreadId,
+    record.rawThreadId,
+    record.threadType,
+    record.peerId ?? null,
+    record.title ?? null,
+    record.isPinned ? 1 : 0,
+    record.isHidden ? 1 : 0,
+    record.isArchived ? 1 : 0,
+    record.rawJson ?? null,
+    now,
+    now
+  ]);
 }
 async function replaceThreadMembers(profile, scopeThreadId, members) {
   const db = await getDb(profile);
   const now = nowIso2();
-  await db.exec("BEGIN");
-  try {
-    await db.run(
-      `DELETE FROM thread_members WHERE profile = ? AND scope_thread_id = ?`,
-      [profile, scopeThreadId]
-    );
-    for (const member of members) {
-      await db.run(
-        `
-          INSERT INTO thread_members (
-            profile, scope_thread_id, user_id, display_name, zalo_name, avatar,
-            account_status, member_type, raw_json, snapshot_at_ms, created_at, updated_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `,
-        [
-          member.profile,
-          member.scopeThreadId,
-          member.userId,
-          member.displayName ?? null,
-          member.zaloName ?? null,
-          member.avatar ?? null,
-          member.accountStatus ?? null,
-          member.memberType ?? null,
-          member.rawJson ?? null,
-          member.snapshotAtMs,
-          now,
-          now
-        ]
-      );
-    }
-    await db.exec("COMMIT");
-  } catch (error) {
-    await db.exec("ROLLBACK");
-    throw error;
-  }
+  const commands = [
+    {
+      sql: `DELETE FROM thread_members WHERE profile = ? AND scope_thread_id = ?`,
+      params: [profile, scopeThreadId]
+    },
+    ...members.map((member) => ({
+      sql: INSERT_THREAD_MEMBER_SQL,
+      params: [
+        member.profile,
+        member.scopeThreadId,
+        member.userId,
+        member.displayName ?? null,
+        member.zaloName ?? null,
+        member.avatar ?? null,
+        member.accountStatus ?? null,
+        member.memberType ?? null,
+        member.rawJson ?? null,
+        member.snapshotAtMs,
+        now,
+        now
+      ]
+    }))
+  ];
+  await db.batch(commands, true);
 }
 async function persistFriend(record) {
   const db = await getDb(record.profile);
@@ -726,49 +813,27 @@ async function persistMessage(record) {
   const db = await getDb(record.profile);
   const now = nowIso2();
   const messageUid = toMessageUid(record);
-  await db.exec("BEGIN");
-  try {
-    await persistThread({
-      profile: record.profile,
-      scopeThreadId: record.scopeThreadId,
-      rawThreadId: record.rawThreadId,
-      threadType: record.threadType,
-      peerId: record.peerId,
-      title: record.title
-    });
-    await db.run(
-      `
-        INSERT INTO messages (
-          profile, message_uid, scope_thread_id, raw_thread_id, thread_type,
-          msg_id, cli_msg_id, action_id, sender_id, sender_name, to_id,
-          timestamp_ms, msg_type, content_text, content_json,
-          quote_msg_id, quote_cli_msg_id, quote_owner_id, quote_text,
-          source, raw_message_json, raw_payload_json, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        ON CONFLICT(profile, message_uid) DO UPDATE SET
-          scope_thread_id = excluded.scope_thread_id,
-          raw_thread_id = excluded.raw_thread_id,
-          thread_type = excluded.thread_type,
-          msg_id = COALESCE(excluded.msg_id, messages.msg_id),
-          cli_msg_id = COALESCE(excluded.cli_msg_id, messages.cli_msg_id),
-          action_id = COALESCE(excluded.action_id, messages.action_id),
-          sender_id = COALESCE(excluded.sender_id, messages.sender_id),
-          sender_name = COALESCE(excluded.sender_name, messages.sender_name),
-          to_id = COALESCE(excluded.to_id, messages.to_id),
-          timestamp_ms = excluded.timestamp_ms,
-          msg_type = COALESCE(excluded.msg_type, messages.msg_type),
-          content_text = COALESCE(excluded.content_text, messages.content_text),
-          content_json = COALESCE(excluded.content_json, messages.content_json),
-          quote_msg_id = COALESCE(excluded.quote_msg_id, messages.quote_msg_id),
-          quote_cli_msg_id = COALESCE(excluded.quote_cli_msg_id, messages.quote_cli_msg_id),
-          quote_owner_id = COALESCE(excluded.quote_owner_id, messages.quote_owner_id),
-          quote_text = COALESCE(excluded.quote_text, messages.quote_text),
-          source = excluded.source,
-          raw_message_json = COALESCE(excluded.raw_message_json, messages.raw_message_json),
-          raw_payload_json = COALESCE(excluded.raw_payload_json, messages.raw_payload_json),
-          updated_at = excluded.updated_at
-      `,
-      [
+  const commands = [
+    {
+      sql: UPSERT_THREAD_SQL,
+      params: [
+        record.profile,
+        record.scopeThreadId,
+        record.rawThreadId,
+        record.threadType,
+        record.peerId ?? null,
+        record.title ?? null,
+        0,
+        0,
+        0,
+        null,
+        now,
+        now
+      ]
+    },
+    {
+      sql: UPSERT_MESSAGE_SQL,
+      params: [
         record.profile,
         messageUid,
         record.scopeThreadId,
@@ -794,64 +859,47 @@ async function persistMessage(record) {
         now,
         now
       ]
-    );
-    await db.run(
-      `DELETE FROM message_media WHERE profile = ? AND message_uid = ?`,
-      [record.profile, messageUid]
-    );
-    await db.run(
-      `DELETE FROM message_mentions WHERE profile = ? AND message_uid = ?`,
-      [record.profile, messageUid]
-    );
-    for (const [index, media] of (record.media ?? []).entries()) {
-      await db.run(
-        `
-          INSERT INTO message_media (
-            profile, message_uid, item_index, media_kind, media_url,
-            media_path, media_type, raw_json, created_at, updated_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `,
-        [
-          record.profile,
-          messageUid,
-          index,
-          media.mediaKind ?? null,
-          media.mediaUrl ?? null,
-          media.mediaPath ?? null,
-          media.mediaType ?? null,
-          media.rawJson ?? null,
-          now,
-          now
-        ]
-      );
-    }
-    for (const [index, mention] of (record.mentions ?? []).entries()) {
-      await db.run(
-        `
-          INSERT INTO message_mentions (
-            profile, message_uid, item_index, target_user_id, pos, len,
-            mention_type, raw_json, created_at, updated_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `,
-        [
-          record.profile,
-          messageUid,
-          index,
-          mention.uid,
-          mention.pos ?? null,
-          mention.len ?? null,
-          mention.type ?? null,
-          mention.rawJson ?? null,
-          now,
-          now
-        ]
-      );
-    }
-    await db.exec("COMMIT");
-  } catch (error) {
-    await db.exec("ROLLBACK");
-    throw error;
-  }
+    },
+    {
+      sql: `DELETE FROM message_media WHERE profile = ? AND message_uid = ?`,
+      params: [record.profile, messageUid]
+    },
+    {
+      sql: `DELETE FROM message_mentions WHERE profile = ? AND message_uid = ?`,
+      params: [record.profile, messageUid]
+    },
+    ...(record.media ?? []).map((media, index) => ({
+      sql: INSERT_MESSAGE_MEDIA_SQL,
+      params: [
+        record.profile,
+        messageUid,
+        index,
+        media.mediaKind ?? null,
+        media.mediaUrl ?? null,
+        media.mediaPath ?? null,
+        media.mediaType ?? null,
+        media.rawJson ?? null,
+        now,
+        now
+      ]
+    })),
+    ...(record.mentions ?? []).map((mention, index) => ({
+      sql: INSERT_MESSAGE_MENTION_SQL,
+      params: [
+        record.profile,
+        messageUid,
+        index,
+        mention.uid,
+        mention.pos ?? null,
+        mention.len ?? null,
+        mention.type ?? null,
+        mention.rawJson ?? null,
+        now,
+        now
+      ]
+    }))
+  ];
+  await db.batch(commands, true);
 }
 async function setSyncState(params) {
   const db = await getDb(params.profile);
@@ -2720,8 +2768,8 @@ function inferReplyMessageThreadId(params) {
 }
 
 // src/cli.ts
-var require2 = createRequire(import.meta.url);
-var { version: PKG_VERSION } = require2("../package.json");
+var require3 = createRequire2(import.meta.url);
+var { version: PKG_VERSION } = require3("../package.json");
 var program = new Command();
 var EMOJI_REACTION_MAP = {
   "\u2764\uFE0F": Reactions.HEART,

package/dist/db-worker.js

@@ -0,0 +1,292 @@
+// src/lib/db-worker.ts
+import { parentPort, workerData } from "worker_threads";
+var INIT_SQL = `
+  PRAGMA journal_mode = WAL;
+  PRAGMA synchronous = FULL;
+  PRAGMA busy_timeout = 5000;
+  PRAGMA foreign_keys = ON;
+
+  CREATE TABLE IF NOT EXISTS threads (
+    profile TEXT NOT NULL,
+    scope_thread_id TEXT NOT NULL,
+    raw_thread_id TEXT NOT NULL,
+    thread_type TEXT NOT NULL,
+    peer_id TEXT,
+    title TEXT,
+    is_pinned INTEGER NOT NULL DEFAULT 0,
+    is_hidden INTEGER NOT NULL DEFAULT 0,
+    is_archived INTEGER NOT NULL DEFAULT 0,
+    raw_json TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (profile, scope_thread_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS thread_members (
+    profile TEXT NOT NULL,
+    scope_thread_id TEXT NOT NULL,
+    user_id TEXT NOT NULL,
+    display_name TEXT,
+    zalo_name TEXT,
+    avatar TEXT,
+    account_status INTEGER,
+    member_type INTEGER,
+    raw_json TEXT,
+    snapshot_at_ms INTEGER NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (profile, scope_thread_id, user_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS friends (
+    profile TEXT NOT NULL,
+    user_id TEXT NOT NULL,
+    display_name TEXT,
+    zalo_name TEXT,
+    avatar TEXT,
+    account_status INTEGER,
+    raw_json TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (profile, user_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS self_profiles (
+    profile TEXT NOT NULL,
+    user_id TEXT NOT NULL,
+    display_name TEXT,
+    info_json TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (profile)
+  );
+
+  CREATE TABLE IF NOT EXISTS messages (
+    profile TEXT NOT NULL,
+    message_uid TEXT NOT NULL,
+    scope_thread_id TEXT NOT NULL,
+    raw_thread_id TEXT NOT NULL,
+    thread_type TEXT NOT NULL,
+    msg_id TEXT,
+    cli_msg_id TEXT,
+    action_id TEXT,
+    sender_id TEXT,
+    sender_name TEXT,
+    to_id TEXT,
+    timestamp_ms INTEGER NOT NULL,
+    msg_type TEXT,
+    content_text TEXT,
+    content_json TEXT,
+    quote_msg_id TEXT,
+    quote_cli_msg_id TEXT,
+    quote_owner_id TEXT,
+    quote_text TEXT,
+    source TEXT NOT NULL,
+    raw_message_json TEXT,
+    raw_payload_json TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (profile, message_uid)
+  );
+
+  CREATE TABLE IF NOT EXISTS message_media (
+    profile TEXT NOT NULL,
+    message_uid TEXT NOT NULL,
+    item_index INTEGER NOT NULL,
+    media_kind TEXT,
+    media_url TEXT,
+    media_path TEXT,
+    media_type TEXT,
+    raw_json TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (profile, message_uid, item_index)
+  );
+
+  CREATE TABLE IF NOT EXISTS message_mentions (
+    profile TEXT NOT NULL,
+    message_uid TEXT NOT NULL,
+    item_index INTEGER NOT NULL,
+    target_user_id TEXT NOT NULL,
+    pos INTEGER,
+    len INTEGER,
+    mention_type INTEGER,
+    raw_json TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (profile, message_uid, item_index)
+  );
+
+  CREATE TABLE IF NOT EXISTS sync_state (
+    profile TEXT NOT NULL,
+    scope TEXT NOT NULL,
+    scope_thread_id TEXT NOT NULL,
+    thread_type TEXT NOT NULL,
+    status TEXT NOT NULL,
+    completeness TEXT,
+    cursor TEXT,
+    last_sync_at TEXT,
+    error TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (profile, scope)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_messages_thread_time
+    ON messages (profile, scope_thread_id, timestamp_ms DESC);
+  CREATE INDEX IF NOT EXISTS idx_messages_msg_id
+    ON messages (profile, msg_id);
+  CREATE INDEX IF NOT EXISTS idx_messages_cli_msg_id
+    ON messages (profile, cli_msg_id);
+  CREATE INDEX IF NOT EXISTS idx_threads_type
+    ON threads (profile, thread_type, updated_at DESC);
+  CREATE INDEX IF NOT EXISTS idx_members_thread
+    ON thread_members (profile, scope_thread_id);
+  CREATE INDEX IF NOT EXISTS idx_friends_name
+    ON friends (profile, display_name, zalo_name, user_id);
+`;
+if (!parentPort) {
+  throw new Error("DB worker requires parentPort");
+}
+var port = parentPort;
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      code: typeof error.code === "string" ? error.code : void 0
+    };
+  }
+  return {
+    name: "Error",
+    message: String(error)
+  };
+}
+async function loadSqliteModule() {
+  const originalEmitWarning = process.emitWarning;
+  const importDynamic = new Function("specifier", "return import(specifier);");
+  process.emitWarning = ((warning, options, ...args) => {
+    const type = typeof options === "string" ? options : void 0;
+    const message = warning instanceof Error ? warning.message : String(warning);
+    if (type === "ExperimentalWarning" && message.includes("SQLite")) {
+      return;
+    }
+    Reflect.apply(originalEmitWarning, process, [warning, options, ...args]);
+  });
+  try {
+    return await importDynamic("node:sqlite");
+  } finally {
+    process.emitWarning = originalEmitWarning;
+  }
+}
+function setDefensiveMode(db) {
+  const maybeDb = db;
+  if (typeof maybeDb.enableDefensive === "function") {
+    maybeDb.enableDefensive(true);
+  }
+}
+function runStatement(db, statement) {
+  return db.prepare(statement.sql).run(...statement.params ?? []);
+}
+function getStatement(db, statement) {
+  return db.prepare(statement.sql).get(...statement.params ?? []);
+}
+function allStatement(db, statement) {
+  return db.prepare(statement.sql).all(...statement.params ?? []);
+}
+async function main() {
+  const { DatabaseSync } = await loadSqliteModule();
+  const { filename } = workerData;
+  const db = new DatabaseSync(filename);
+  db.exec(INIT_SQL);
+  setDefensiveMode(db);
+  port.postMessage({ type: "ready" });
+  port.on("message", (message) => {
+    try {
+      switch (message.type) {
+        case "exec":
+          db.exec(message.payload.sql);
+          port.postMessage({
+            type: "result",
+            id: message.id,
+            result: null
+          });
+          return;
+        case "run":
+          port.postMessage({
+            type: "result",
+            id: message.id,
+            result: runStatement(db, message.payload)
+          });
+          return;
+        case "get":
+          port.postMessage({
+            type: "result",
+            id: message.id,
+            result: getStatement(db, message.payload) ?? null
+          });
+          return;
+        case "all":
+          port.postMessage({
+            type: "result",
+            id: message.id,
+            result: allStatement(db, message.payload)
+          });
+          return;
+        case "batch":
+          if (message.payload.transactional) {
+            db.exec("BEGIN");
+          }
+          try {
+            for (const command of message.payload.commands) {
+              if ((command.params ?? []).length === 0) {
+                db.exec(command.sql);
+              } else {
+                runStatement(db, command);
+              }
+            }
+            if (message.payload.transactional) {
+              db.exec("COMMIT");
+            }
+          } catch (error) {
+            if (message.payload.transactional) {
+              try {
+                db.exec("ROLLBACK");
+              } catch {
+              }
+            }
+            throw error;
+          }
+          port.postMessage({
+            type: "result",
+            id: message.id,
+            result: null
+          });
+          return;
+        case "close":
+          db.close();
+          port.postMessage({
+            type: "result",
+            id: message.id,
+            result: null
+          });
+          setImmediate(() => process.exit(0));
+          return;
+      }
+    } catch (error) {
+      port.postMessage({
+        type: "error",
+        id: message.id,
+        error: serializeError(error)
+      });
+    }
+  });
+}
+void main().catch((error) => {
+  port.postMessage({
+    type: "fatal",
+    error: serializeError(error)
+  });
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzca",
-  "version": "0.1.50",
+  "version": "0.1.51",
   "description": "Open-source zca-compatible CLI to integrate Zalo with OpenClaw",
   "type": "module",
   "bin": {
@@ -14,11 +14,14 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup src/cli.ts --format esm --target node18 --out-dir dist --clean",
+    "build": "npm run build:cli && npm run build:worker",
+    "build:cli": "tsup src/cli.ts --format esm --target node22 --out-dir dist --clean",
+    "build:worker": "tsup src/lib/db-worker.ts --format esm --target node22 --out-dir dist",
     "dev": "tsx src/cli.ts",
     "test": "tsx --test tests/*.test.ts",
     "typecheck": "tsc -p tsconfig.json",
     "lint": "tsc -p tsconfig.json --noEmit",
+    "prepare": "npm run build",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -39,15 +42,13 @@
     "url": "https://github.com/darkamenosa/openzca/issues"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=22.13.0"
   },
   "dependencies": {
     "@types/qrcode-terminal": "^0.12.2",
     "commander": "^14.0.3",
     "image-size": "^2.0.2",
     "qrcode-terminal": "^0.12.0",
-    "sqlite": "^5.1.1",
-    "sqlite3": "^6.0.1",
     "zca-js": "^2.1.2"
   },
   "devDependencies": {