@qzhuli/qzhuli-cli 0.2.1 → 0.3.0-rc.1

package/dist/cmd.js

@@ -11133,7 +11133,7 @@ var require_protos = __commonJS({
 
 // src/cmd.ts
 init_cjs_shims();
-var import_commander8 = require("commander");
+var import_commander9 = require("commander");
 
 // src/commands/auth/index.ts
 init_cjs_shims();
@@ -11244,10 +11244,27 @@ var commands = {
     desc: "Conversation operations",
     listDesc: "List all conversations",
     limitOption: "Max conversations to retrieve",
+    offsetOption: "Skip first N conversations",
     createDesc: "Create conversation",
     createArgDesc: "User UID",
     createAgentIdOption: "Agent ID",
-    createSuccess: "Conversation created."
+    createSuccess: "Conversation created.",
+    profileDesc: "Get conversation details",
+    profileArgDesc: "Conversation ID",
+    typeOption: "Conversation type (1=private, 2=group, auto-detect if omitted)",
+    profileSuccess: "Conversation details retrieved.",
+    searchDesc: "Find all conversations with a user by Q\u52A9\u53F7 or UID",
+    searchArgDesc: "Query string (default: Q\u52A9\u53F7)",
+    searchByUid: "Search by UID",
+    searchNotFound: "No conversations found with {name}.",
+    searchSuccess: "Found {count} conversation(s) with {name}."
+  },
+  cache: {
+    desc: "Manage local cache",
+    syncDesc: "Sync all data to local cache",
+    statusDesc: "Show cache status",
+    clearDesc: "Clear cache",
+    clearTableOption: "Clear specific cache table"
   }
 };
 var messages = {
@@ -11374,10 +11391,27 @@ var commands2 = {
     desc: "\u4F1A\u8BDD\u64CD\u4F5C",
     listDesc: "\u5217\u51FA\u6240\u6709\u4F1A\u8BDD",
     limitOption: "\u6700\u5927\u4F1A\u8BDD\u6570",
+    offsetOption: "\u8DF3\u8FC7\u524D N \u6761\u4F1A\u8BDD",
     createDesc: "\u521B\u5EFA\u4F1A\u8BDD",
     createArgDesc: "\u7528\u6237UID",
     createAgentIdOption: "\u52A9\u7406ID",
-    createSuccess: "\u4F1A\u8BDD\u521B\u5EFA\u6210\u529F\u3002"
+    createSuccess: "\u4F1A\u8BDD\u521B\u5EFA\u6210\u529F\u3002",
+    profileDesc: "\u67E5\u8BE2\u4F1A\u8BDD\u8BE6\u60C5",
+    profileArgDesc: "\u4F1A\u8BDDID",
+    typeOption: "\u4F1A\u8BDD\u7C7B\u578B\uFF081=\u79C1\u804A, 2=\u7FA4\u804A\uFF0C\u4E0D\u4F20\u81EA\u52A8\u5224\u65AD\uFF09",
+    profileSuccess: "\u5DF2\u83B7\u53D6\u4F1A\u8BDD\u8BE6\u60C5\u3002",
+    searchDesc: "\u901A\u8FC7Q\u52A9\u53F7\u6216UID\u67E5\u627E\u4E0E\u67D0\u7528\u6237\u7684\u6240\u6709\u4F1A\u8BDD",
+    searchArgDesc: "\u67E5\u8BE2\u5185\u5BB9\uFF08\u9ED8\u8BA4\u6309 Q\u52A9\u53F7\uFF09",
+    searchByUid: "\u6309 UID \u641C\u7D22",
+    searchNotFound: "\u672A\u627E\u5230\u4E0E {name} \u7684\u4F1A\u8BDD\u3002",
+    searchSuccess: "\u627E\u5230\u4E0E {name} \u7684 {count} \u4E2A\u4F1A\u8BDD\u3002"
+  },
+  cache: {
+    desc: "\u7BA1\u7406\u672C\u5730\u7F13\u5B58",
+    syncDesc: "\u540C\u6B65\u6240\u6709\u6570\u636E\u5230\u672C\u5730\u7F13\u5B58",
+    statusDesc: "\u663E\u793A\u7F13\u5B58\u72B6\u6001",
+    clearDesc: "\u6E05\u9664\u7F13\u5B58",
+    clearTableOption: "\u6E05\u9664\u6307\u5B9A\u7F13\u5B58\u8868"
   }
 };
 var messages2 = {
@@ -12242,10 +12276,121 @@ function NewCmdAuth(factory) {
   return cmd;
 }
 
-// src/commands/config/index.ts
+// src/commands/cache/index.ts
 init_cjs_shims();
 var import_commander2 = require("commander");
 
+// src/commands/cache/clear.ts
+init_cjs_shims();
+async function cacheClearRun(factory, opts) {
+  if (opts.table) {
+    switch (opts.table) {
+      case "conversations":
+        factory.repos.conversation.clear();
+        break;
+      case "contacts":
+        factory.repos.contact.clear();
+        break;
+      case "users":
+        factory.repos.user.clear();
+        break;
+      case "relations":
+        factory.repos.relation.clear();
+        break;
+      case "messages":
+        factory.repos.message.clear();
+        break;
+      default:
+        return {
+          status: "error",
+          code: "INVALID_ARGUMENT" /* INVALID_ARGUMENT */,
+          message: t("commands.cache.unknownTable").replace("{table}", opts.table),
+          data: null
+        };
+    }
+  } else {
+    factory.repos.conversation.clear();
+    factory.repos.contact.clear();
+    factory.repos.user.clear();
+    factory.repos.relation.clear();
+    factory.repos.message.clear();
+  }
+  return {
+    status: "success",
+    code: "CONFIG_UPDATED" /* CONFIG_UPDATED */,
+    message: opts.table ? t("commands.cache.clearTableSuccess").replace("{table}", opts.table) : t("commands.cache.clearSuccess"),
+    data: null
+  };
+}
+
+// src/commands/cache/status.ts
+init_cjs_shims();
+async function cacheStatusRun(factory) {
+  const [convStatus, contactStatus] = await Promise.all([
+    factory.repos.conversation.getStatus(),
+    factory.repos.contact.getStatus()
+  ]);
+  return {
+    status: "success",
+    code: "CONFIG_RETRIEVED" /* CONFIG_RETRIEVED */,
+    message: "Cache status:",
+    data: {
+      conversations: {
+        count: convStatus.count,
+        lastSyncAt: convStatus.lastSyncAt ? new Date(convStatus.lastSyncAt).toISOString() : "never"
+      },
+      contacts: {
+        count: contactStatus.count,
+        lastSyncAt: contactStatus.lastSyncAt ? new Date(contactStatus.lastSyncAt).toISOString() : "never"
+      }
+    }
+  };
+}
+
+// src/commands/cache/sync.ts
+init_cjs_shims();
+async function cacheSyncRun(factory) {
+  try {
+    await factory.repos.contact.sync();
+    await factory.repos.conversation.sync();
+  } catch (error) {
+    return {
+      status: "error",
+      code: "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+      message: error instanceof Error ? error.message : "Cache sync failed.",
+      data: null
+    };
+  }
+  return {
+    status: "success",
+    code: "CONFIG_UPDATED" /* CONFIG_UPDATED */,
+    message: t("commands.cache.syncSuccess"),
+    data: null
+  };
+}
+
+// src/commands/cache/index.ts
+function NewCmdCache(factory) {
+  const cmd = new import_commander2.Command("cache").description(t("commands.cache.desc"));
+  cmd.command("sync").description(t("commands.cache.syncDesc")).action(async () => {
+    const result = await cacheSyncRun(factory);
+    handleCommand(result);
+  });
+  cmd.command("status").description(t("commands.cache.statusDesc")).action(async () => {
+    const result = await cacheStatusRun(factory);
+    handleCommand(result);
+  });
+  cmd.command("clear").description(t("commands.cache.clearDesc")).option("--table <table>", t("commands.cache.clearTableOption")).action(async (opts) => {
+    const result = await cacheClearRun(factory, { table: opts.table });
+    handleCommand(result);
+  });
+  return cmd;
+}
+
+// src/commands/config/index.ts
+init_cjs_shims();
+var import_commander3 = require("commander");
+
 // src/commands/config/get.ts
 init_cjs_shims();
 function configGetRun(_factory, opts) {
@@ -12273,7 +12418,7 @@ function configGetRun(_factory, opts) {
 
 // src/commands/config/index.ts
 function NewCmdConfig(factory) {
-  const cmd = new import_commander2.Command("config").description(t("commands.config.desc"));
+  const cmd = new import_commander3.Command("config").description(t("commands.config.desc"));
   cmd.option("--locale <language>", t("commands.config.localeOption")).option("--debug", t("commands.config.debugOn")).option("--no-debug", t("commands.config.debugOff")).action((opts) => {
     const result = configGetRun(factory, {
       locale: opts.locale,
@@ -12286,7 +12431,7 @@ function NewCmdConfig(factory) {
 
 // src/commands/conversation/index.ts
 init_cjs_shims();
-var import_commander3 = require("commander");
+var import_commander4 = require("commander");
 
 // src/commands/conversation/create.ts
 init_cjs_shims();
@@ -12311,8 +12456,11 @@ async function conversationCreateRun(factory, opts) {
 // src/commands/conversation/list.ts
 init_cjs_shims();
 async function conversationListRun(factory, opts) {
-  const result = await factory.imGateway.queryConversations({ limit: opts.limit });
-  if (result.status === "error" && result.code === "AUTH_FAILED" /* AUTH_FAILED */) {
+  const result = await factory.repos.conversation.queryAll({
+    limit: opts.limit,
+    offset: opts.offset
+  });
+  if (!result.ok && result.code === "AUTH_FAILED" /* AUTH_FAILED */) {
     return {
       status: "error",
       code: "AUTH_FAILED" /* AUTH_FAILED */,
@@ -12320,15 +12468,150 @@ async function conversationListRun(factory, opts) {
       data: null
     };
   }
-  return result;
+  return {
+    status: result.ok ? "success" : "error",
+    code: result.ok ? "CONVERSATION_LIST" /* CONVERSATION_LIST */ : result.code,
+    message: result.ok ? `Conversations (${result.data.length}):` : result.message,
+    data: result.ok ? { conversations: result.data } : null
+  };
+}
+
+// src/commands/conversation/profile.ts
+init_cjs_shims();
+async function conversationProfileRun(factory, opts) {
+  const result = await factory.repos.conversation.getProfile(
+    opts.conversationId,
+    opts.conversationType
+  );
+  if (!result.ok) {
+    return {
+      status: "error",
+      code: result.code,
+      message: result.code === "AUTH_FAILED" /* AUTH_FAILED */ ? t("auth.notAuthenticated") : result.message,
+      data: null
+    };
+  }
+  return {
+    status: "success",
+    code: "CONVERSATION_LIST" /* CONVERSATION_LIST */,
+    message: t("commands.conversation.profileSuccess"),
+    data: result.data
+  };
+}
+
+// src/commands/conversation/search.ts
+init_cjs_shims();
+function convertUser(raw) {
+  const user = {
+    id: raw.id,
+    cid: raw.cid,
+    uid: raw.uid,
+    nickname: raw.nickname,
+    avatar: raw.avatar,
+    status: raw.status
+  };
+  if (raw.link_name) user.linkName = raw.link_name;
+  if (raw.member_delete_time) user.memberDeleteTime = raw.member_delete_time;
+  if (raw.agent) {
+    const a = raw.agent;
+    const agentVoice = a.voice ? {
+      code: a.voice.code,
+      ...a.voice.voice_name ? { voiceName: a.voice.voice_name } : {},
+      ...a.voice.file_link ? { fileLink: a.voice.file_link } : {},
+      ...a.voice.text ? { text: a.voice.text } : {}
+    } : void 0;
+    user.agent = {
+      id: a.id,
+      title: a.title,
+      avatar: a.avatar,
+      packageIcon: a.package_icon,
+      packageLevel: a.package_level,
+      ...a.background !== void 0 ? { background: a.background } : {},
+      ...a.agent_type !== void 0 ? { agentType: a.agent_type } : {},
+      ...agentVoice ? { voice: agentVoice } : {}
+    };
+  }
+  return user;
+}
+function convertVisitor(raw) {
+  return { id: raw.id, cid: raw.cid };
+}
+function profileToItem(profile) {
+  const convData = profile.conversation;
+  return {
+    conversationId: convData.conversation_id,
+    blackStatus: convData.black_status,
+    isGroup: convData.is_group,
+    name: convData.name,
+    avatar: convData.avatar,
+    sourceType: convData.source_type,
+    classesId: convData.classes_id,
+    classesName: convData.classes_name,
+    teamId: convData.team_id,
+    teamName: convData.team_name,
+    users: profile.users.map(convertUser),
+    visitors: profile.visitors.map(convertVisitor)
+  };
+}
+async function conversationSearchRun(factory, opts) {
+  const userResult = opts.byUid ? await factory.repos.user.findUserById(opts.query) : await factory.repos.user.searchUserById(opts.query);
+  if (!userResult.ok) {
+    return {
+      status: "error",
+      code: userResult.code,
+      message: userResult.code === "AUTH_FAILED" /* AUTH_FAILED */ ? t("auth.notAuthenticated") : userResult.message,
+      data: null
+    };
+  }
+  if (!userResult.data) {
+    return {
+      status: "error",
+      code: "USER_NOT_FOUND_NEEDS_RESOLUTION" /* USER_NOT_FOUND_NEEDS_RESOLUTION */,
+      message: t("messages.notFound"),
+      data: null
+    };
+  }
+  const targetId = userResult.data.id;
+  const targetUid = userResult.data.uid;
+  const nickname = userResult.data.nickname;
+  const profilesResult = await factory.repos.conversation.searchByUid(targetUid);
+  if (!profilesResult.ok || profilesResult.data.length === 0) {
+    return {
+      status: "success",
+      code: "NOT_FOUND" /* NOT_FOUND */,
+      message: t("commands.conversation.searchNotFound").replace("{name}", nickname),
+      data: null
+    };
+  }
+  const results = profilesResult.data.map(profileToItem);
+  const result = {
+    id: targetId,
+    uid: targetUid,
+    nickname,
+    conversations: results
+  };
+  return {
+    status: "success",
+    code: "CONVERSATION_LIST" /* CONVERSATION_LIST */,
+    message: t("commands.conversation.searchSuccess").replace("{name}", nickname).replace("{count}", String(results.length)),
+    data: result
+  };
 }
 
 // src/commands/conversation/index.ts
 function NewCmdConversation(factory) {
-  const cmd = new import_commander3.Command("conversation").description(t("commands.conversation.desc"));
-  cmd.command("list").description(t("commands.conversation.listDesc")).option("--limit <n>", t("commands.conversation.limitOption"), "50").action(async (options3) => {
+  const cmd = new import_commander4.Command("conversation").description(t("commands.conversation.desc"));
+  cmd.command("list").description(t("commands.conversation.listDesc")).option("--limit <n>", t("commands.conversation.limitOption"), "50").option("--offset <n>", t("commands.conversation.offsetOption"), "0").action(async (options3) => {
     const result = await conversationListRun(factory, {
-      limit: parseInt(options3.limit, 10)
+      limit: parseInt(options3.limit, 10),
+      offset: parseInt(options3.offset, 10)
+    });
+    handleCommand(result);
+  });
+  cmd.command("profile").description(t("commands.conversation.profileDesc")).argument("<id>", t("commands.conversation.profileArgDesc")).option("--type <n>", t("commands.conversation.typeOption")).action(async (id, opts) => {
+    const result = await conversationProfileRun(factory, {
+      conversationId: id,
+      conversationType: opts.type ? parseInt(opts.type, 10) : void 0
     });
     handleCommand(result);
   });
@@ -12336,17 +12619,21 @@ function NewCmdConversation(factory) {
     const result = await conversationCreateRun(factory, { uid, agentId: opts.agentId });
     handleCommand(result);
   });
+  cmd.command("search").description(t("commands.conversation.searchDesc")).argument("<query>", t("commands.conversation.searchArgDesc")).option("--uid", t("commands.conversation.searchByUid")).action(async (query, opts) => {
+    const result = await conversationSearchRun(factory, { query, byUid: opts.uid });
+    handleCommand(result);
+  });
   return cmd;
 }
 
 // src/commands/friend/index.ts
 init_cjs_shims();
-var import_commander4 = require("commander");
+var import_commander5 = require("commander");
 
 // src/commands/friend/list.ts
 init_cjs_shims();
 async function friendListRun(factory) {
-  const result = await factory.gateway.getLinksContacts();
+  const result = await factory.repos.contact.getLinksContacts();
   if (!result.ok) {
     return {
       status: "error",
@@ -12376,7 +12663,7 @@ async function friendListRun(factory) {
 // src/commands/friend/profile.ts
 init_cjs_shims();
 async function friendProfileRun(factory, opts) {
-  const listResult = await factory.gateway.getLinksContacts();
+  const listResult = await factory.repos.contact.getLinksContacts();
   if (!listResult.ok) {
     return {
       status: "error",
@@ -12461,7 +12748,7 @@ async function friendProfileRun(factory, opts) {
       }
     };
   }
-  const profileResult = await factory.gateway.getUserAgentProfile(match.uid);
+  const profileResult = await factory.repos.user.getUserAgentProfile(match.uid);
   if (!profileResult.ok) {
     return {
       status: "error",
@@ -12494,7 +12781,7 @@ async function friendProfileRun(factory, opts) {
 
 // src/commands/friend/index.ts
 function NewCmdFriend(factory) {
-  const cmd = new import_commander4.Command("friend").description(t("commands.friend.desc"));
+  const cmd = new import_commander5.Command("friend").description(t("commands.friend.desc"));
   cmd.command("list").description(t("commands.friend.listDesc")).action(async () => {
     const result = await friendListRun(factory);
     handleCommand(result);
@@ -12512,7 +12799,7 @@ function NewCmdFriend(factory) {
 
 // src/commands/message/index.ts
 init_cjs_shims();
-var import_commander5 = require("commander");
+var import_commander6 = require("commander");
 
 // src/commands/message/history.ts
 init_cjs_shims();
@@ -12522,8 +12809,8 @@ async function messageHistoryRun(factory, opts) {
     direction: opts.direction,
     limit: opts.limit
   };
-  const result = await factory.imGateway.pullMessages(opts.conversationId, pullOpts);
-  if (result.status === "error" && result.code === "AUTH_FAILED" /* AUTH_FAILED */) {
+  const result = await factory.repos.message.pullMessages(opts.conversationId, pullOpts);
+  if (!result.ok && result.code === "AUTH_FAILED" /* AUTH_FAILED */) {
     return {
       status: "error",
       code: "AUTH_FAILED" /* AUTH_FAILED */,
@@ -12531,7 +12818,12 @@ async function messageHistoryRun(factory, opts) {
       data: null
     };
   }
-  return result;
+  return {
+    status: result.ok ? "success" : "error",
+    code: result.ok ? "MESSAGE_HISTORY" /* MESSAGE_HISTORY */ : result.code,
+    message: result.ok ? `Messages (${result.data.messages.length}):` : result.message,
+    data: result.ok ? result.data : null
+  };
 }
 
 // src/commands/message/send.ts
@@ -12555,7 +12847,7 @@ async function messageSendRun(factory, opts) {
 
 // src/commands/message/index.ts
 function NewCmdMessage(factory) {
-  const cmd = new import_commander5.Command("message").description(t("commands.message.desc"));
+  const cmd = new import_commander6.Command("message").description(t("commands.message.desc"));
   cmd.command("send <conversation-id> <target-cid> <content>").description(t("commands.message.sendDesc")).action(async (conversationId, targetCid, content) => {
     const result = await messageSendRun(factory, { conversationId, targetCid, content });
     handleCommand(result);
@@ -12574,12 +12866,12 @@ function NewCmdMessage(factory) {
 
 // src/commands/relation/index.ts
 init_cjs_shims();
-var import_commander6 = require("commander");
+var import_commander7 = require("commander");
 
 // src/commands/relation/get.ts
 init_cjs_shims();
 async function relationGetRun(factory, opts) {
-  const result = await factory.gateway.getLinkNameType(opts.friendUid);
+  const result = await factory.repos.relation.getLinkNameType(opts.friendUid);
   if (!result.ok) {
     return {
       status: "error",
@@ -12647,7 +12939,7 @@ async function relationSetRun(factory, opts) {
 
 // src/commands/relation/index.ts
 function NewCmdRelation(factory) {
-  const cmd = new import_commander6.Command("relation").description(t("commands.relation.desc"));
+  const cmd = new import_commander7.Command("relation").description(t("commands.relation.desc"));
   cmd.command("get <uid>").description(t("commands.relation.getDesc")).action(async (uid) => {
     const result = await relationGetRun(factory, { friendUid: uid });
     handleCommand(result);
@@ -12665,7 +12957,7 @@ function NewCmdRelation(factory) {
 
 // src/commands/user/index.ts
 init_cjs_shims();
-var import_commander7 = require("commander");
+var import_commander8 = require("commander");
 
 // src/commands/user/add.ts
 init_cjs_shims();
@@ -12720,7 +13012,7 @@ async function userAddRun(factory, opts) {
 // src/commands/user/search.ts
 init_cjs_shims();
 async function userSearchRun(factory, opts) {
-  const result = opts.byUid ? await factory.gateway.findUserById(opts.query) : await factory.gateway.searchUserById(opts.query);
+  const result = opts.byUid ? await factory.repos.user.findUserById(opts.query) : await factory.repos.user.searchUserById(opts.query);
   if (!result.ok) {
     return {
       status: "error",
@@ -12748,7 +13040,7 @@ async function userSearchRun(factory, opts) {
 
 // src/commands/user/index.ts
 function NewCmdUser(factory) {
-  const cmd = new import_commander7.Command("user").description(t("commands.user.desc"));
+  const cmd = new import_commander8.Command("user").description(t("commands.user.desc"));
   cmd.command("search").description(t("commands.user.searchDesc")).argument("<query>", t("commands.user.searchArgDesc")).option("--uid", t("commands.user.searchByUid")).action(async (query, opts) => {
     const result = await userSearchRun(factory, { query, byUid: opts.uid });
     handleCommand(result);
@@ -12887,6 +13179,23 @@ var ApiGateway = class {
       friend_agent_id: friendAgentId
     });
   }
+  /** POST /user/get_profile_by_conversation_id — auth required */
+  getProfileByConversationId(conversationId, conversationType) {
+    const auth3 = this.requireAuth();
+    if (!auth3.ok) return Promise.resolve(auth3);
+    const params = {
+      uid: auth3.data,
+      conversation_id: conversationId
+    };
+    if (conversationType !== void 0) {
+      params.conversation_type = conversationType;
+    }
+    return this.client.performRequest(
+      "/user/get_profile_by_conversation_id",
+      "POST",
+      params
+    );
+  }
 };
 
 // src/internal/api-client.ts
@@ -13099,6 +13408,33 @@ var IMClient = class {
       console.log("[DEBUG]", ...args);
     }
   }
+  /** Convert a protobuf Long to a readable string. */
+  longStr(v) {
+    if (!v) return "0";
+    if (typeof v === "object" && "low" in v && "high" in v) {
+      return v.toString();
+    }
+    return String(v);
+  }
+  /** Map operation code to a human-readable name. */
+  opName(code) {
+    const map = {
+      1: "KeepAlive",
+      1e3: "ClientOpen",
+      1001: "ClientClose",
+      1003: "ConversationQuery",
+      2e3: "ConversationMessageSend",
+      2001: "ConversationMessagePull",
+      2005: "ConversationMessagePush",
+      3e3: "Ack"
+    };
+    return map[code] ?? `Op(${code})`;
+  }
+  /** Format byte size for display. */
+  size(n) {
+    if (n < 1024) return `${n}B`;
+    return `${(n / 1024).toFixed(1)}KB`;
+  }
   isConnected() {
     return this.connected;
   }
@@ -13106,9 +13442,11 @@ var IMClient = class {
   async connect() {
     return new Promise((resolve2, reject) => {
       const wsUrl = this.buildWsUrl();
+      this.debug(`\u2192 CONNECT ${wsUrl}, cid=${this.config.cid}`);
       this.ws = new import_ws.default(wsUrl);
       this.ws.binaryType = "arraybuffer";
       this.ws.on("open", () => {
+        this.debug("  \u2713 Connected");
         clearTimeout(timeout);
         this.connected = true;
         this.onEvent({ type: "connected" });
@@ -13116,13 +13454,17 @@ var IMClient = class {
         resolve2();
       });
       this.ws.on("message", (data) => {
-        this.handleResponse(data);
+        const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        this.debug(`  \u2190 ${this.size(buf.length)} received`);
+        this.handleResponse(buf);
       });
-      this.ws.on("close", (_code, reason) => {
+      this.ws.on("close", (code, reason) => {
+        this.debug(`  \u2717 Closed (code: ${code}, reason: ${reason.toString()})`);
         this.connected = false;
         this.onEvent({ type: "disconnected", reason: reason.toString() });
       });
       this.ws.on("error", (err) => {
+        this.debug(`  \u2717 Error: ${err instanceof Error ? err.message : String(err)}`);
         this.onEvent({ type: "error", error: err });
         reject(err);
       });
@@ -13135,6 +13477,7 @@ var IMClient = class {
   /** Close the IM connection. */
   close() {
     if (this.ws) {
+      this.debug(`\u2192 CLOSE`);
       this.ws.close();
       this.ws = null;
       this.connected = false;
@@ -13174,13 +13517,21 @@ var IMClient = class {
       const handler = (ack) => {
         clearTimeout(timeout);
         this.ws?.off("message", onMessage);
+        this.debug(
+          `  \u2713 Ack, msg=${ack.messageId}, blocked=${ack.blocked}, moderated=${ack.moderated}`
+        );
         resolve2(ack);
       };
       const onMessage = (data2) => {
         const response = this.root.IMResponse.decode(new Uint8Array(data2));
-        if (response.operation === this.root.IMOperation.Ack || response.operation === this.root.IMOperation.ConversationMessageSend) {
-          if (response.blob && response.blob.length > 0) {
+        const op = response.operation;
+        const blobLen = response.blob?.length ?? 0;
+        if (op === this.root.IMOperation.Ack || op === this.root.IMOperation.ConversationMessageSend) {
+          if (blobLen > 0) {
             const ack = this.root.MsgAck.decode(new Uint8Array(response.blob));
+            this.debug(
+              `  \u2190 ${this.opName(op)} ${this.size(blobLen)}, id=${this.longStr(ack.id)}, blocked=${ack.blocked}, ackTs=${this.longStr(ack.ackTs)}`
+            );
             handler({
               messageId: String(ack.id),
               conversationId: ack.conversationId,
@@ -13192,14 +13543,15 @@ var IMClient = class {
               ackTs: ack.ackTs ? Number(ack.ackTs) : 0
             });
           } else {
-            this.debug("sendMessage ack received with empty blob, operation:", response.operation);
+            this.debug(`  \u2190 ${this.opName(op)} (empty blob, ignored)`);
           }
         } else {
-          this.debug("sendMessage ignored message, operation:", response.operation);
+          this.debug(`  \u2190 ${this.opName(op)} ${this.size(blobLen)} (ignored, not ack)`);
         }
       };
       this.ws?.on("message", onMessage);
       const data = this.root.IMRequest.encode(request).finish();
+      this.debug(`\u2192 ${this.opName(2e3)} ${this.size(data.length)} to: ${targetCid}`);
       this.ws?.send(Buffer.from(data));
     });
   }
@@ -13230,6 +13582,7 @@ var IMClient = class {
           clearTimeout(timeout);
           this.ws?.off("message", onMessage);
           if (!response.blob || response.blob.length === 0) {
+            this.debug(`  \u2190 ${this.opName(2001)} (empty, no messages)`);
             resolve2({
               messages: [],
               finished: true,
@@ -13244,6 +13597,9 @@ var IMClient = class {
             return;
           }
           const msgList = this.root.MsgList.decode(new Uint8Array(response.blob));
+          this.debug(
+            `  \u2190 ${this.opName(2001)}, ${msgList.msgs?.length ?? 0} msgs, finished=${msgList.finished}, lastId=${this.longStr(msgList.lastId)}`
+          );
           const debug = this.debugEnabled;
           const messages3 = [];
           for (const msg of msgList.msgs) {
@@ -13271,6 +13627,9 @@ var IMClient = class {
               timestamp: msg.ackTs ? Number(msg.ackTs) : msg.jetTs ? Number(msg.jetTs) : 0
             };
             if (debug) {
+              this.debug(
+                `    #${pulledMsg.id} ${pulledMsg.type} ${pulledMsg.role} from ${pulledMsg.senderCid} (${pulledMsg.content.length} chars, ${pulledMsg.extraContents.length} extras)`
+              );
               if (msg.blob && msg.blob.length > 0)
                 pulledMsg.rawBlob = Buffer.from(msg.blob).toString("base64");
               if (msg.blobExtra && msg.blobExtra.length > 0)
@@ -13278,6 +13637,7 @@ var IMClient = class {
             }
             messages3.push(pulledMsg);
           }
+          this.debug(`  \u2713 ${messages3.length} messages resolved`);
           resolve2({
             messages: messages3,
             finished: msgList.finished,
@@ -13301,13 +13661,11 @@ var IMClient = class {
     });
   }
   /** Query all conversations for the user. */
-  async queryConversations(options3) {
+  async queryConversations() {
     if (!this.ws || !this.connected) {
       throw new Error("Not connected to IM server");
     }
-    const queryBlob = this.root.ConversationQueryParams.create({
-      limit: options3?.limit ?? 0
-    });
+    const queryBlob = this.root.ConversationQueryParams.create({});
     const request = this.root.IMRequest.create({
       operation: this.root.IMOperation.ConversationQuery,
       cid: this.config.cid,
@@ -13324,6 +13682,7 @@ var IMClient = class {
           clearTimeout(timeout);
           this.ws?.off("message", onMessage);
           if (!response.blob || response.blob.length === 0) {
+            this.debug(`  \u2190 ${this.opName(1003)} (empty, no conversations)`);
             resolve2({
               conversations: [],
               limit: 0,
@@ -13334,6 +13693,7 @@ var IMClient = class {
             return;
           }
           const list = this.root.ConversationList.decode(new Uint8Array(response.blob));
+          this.debug(`  \u2190 ${this.opName(1003)} ${list.convs?.length ?? 0} conversations`);
           const debug = this.debugEnabled;
           const conversations3 = [];
           for (const conv of list.convs ?? []) {
@@ -13394,13 +13754,18 @@ var IMClient = class {
       ts: Date.now()
     });
     const data = this.root.IMRequest.encode(request).finish();
+    this.debug(`\u2192 ${this.opName(1e3)} ${this.size(data.length)}, cid=${this.config.cid}`);
     this.ws.send(Buffer.from(data));
   }
   handleResponse(data) {
     try {
       const response = this.root.IMResponse.decode(new Uint8Array(data));
-      if (response.operation === this.root.IMOperation.ConversationMessagePush) {
+      const op = response.operation;
+      if (op === this.root.IMOperation.ConversationMessagePush) {
         const msgList = this.root.MsgList.decode(new Uint8Array(response.blob));
+        this.debug(
+          `  \u2190 ${this.opName(op)}, ${msgList.msgs?.length ?? 0} msgs, conv=${msgList.convId}`
+        );
         const debug = this.debugEnabled;
         for (const msg of msgList.msgs) {
           const extraContents = (msg.extraContents ?? []).map((ec) => {
@@ -13427,6 +13792,9 @@ var IMClient = class {
             timestamp: msg.ackTs ? Number(msg.ackTs) : msg.jetTs ? Number(msg.jetTs) : 0
           };
           if (debug) {
+            this.debug(
+              `    #${pulledMsg.id} ${pulledMsg.type} ${pulledMsg.role} from ${pulledMsg.senderCid} (${pulledMsg.content.length} chars)`
+            );
             if (msg.blob && msg.blob.length > 0)
               pulledMsg.rawBlob = Buffer.from(msg.blob).toString("base64");
             if (msg.blobExtra && msg.blobExtra.length > 0)
@@ -13437,6 +13805,11 @@ var IMClient = class {
             message: pulledMsg
           });
         }
+      } else {
+        const blobLen = response.blob?.length ?? 0;
+        this.debug(
+          `  \u2190 ${this.opName(op)} ${this.size(blobLen)} (unhandled, no handler registered)`
+        );
       }
     } catch (err) {
       this.debug("handleResponse decode error:", err instanceof Error ? err.message : String(err));
@@ -13451,20 +13824,28 @@ var IMGateway = class {
   }
   config;
   dryRun = false;
+  /** Log debug output when debug mode is enabled. */
+  debug(...args) {
+    if (this.config.debugEnabled) {
+      console.log("[DEBUG]", ...args);
+    }
+  }
   setDryRun(enabled) {
     this.dryRun = enabled;
   }
   /** Execute a function with an IM connection, ensuring connect/close lifecycle. */
   async withConnection(fn) {
+    this.debug("\u2500\u2500 new connection \u2500\u2500");
     const client = new IMClient(this.config, (event) => {
-      if (event.type === "error" && this.config.debugEnabled) {
-        console.error("[IM] error event:", event.error.message);
+      if (event.type === "error") {
+        this.debug(`  \u2717 IM error: ${event.error.message}`);
       }
     });
     try {
       await client.connect();
       return await fn(client);
     } finally {
+      this.debug("\u2500\u2500 connection closed \u2500\u2500");
       client.close();
     }
   }
@@ -13559,7 +13940,7 @@ var IMGateway = class {
       };
     }
     try {
-      const result = await this.withConnection((client) => client.queryConversations(options3));
+      const result = await this.withConnection((client) => client.queryConversations());
       let conversations3 = result.conversations.map((conv) => ({
         id: conv.id,
         name: conv.name,
@@ -13573,6 +13954,9 @@ var IMGateway = class {
         extraDecoded: conv.extraDecoded,
         rawExtra: conv.rawExtra
       }));
+      if (options3?.offset && options3.offset > 0) {
+        conversations3 = conversations3.slice(options3.offset);
+      }
       if (options3?.limit && options3.limit > 0) {
         conversations3 = conversations3.slice(0, options3.limit);
       }
@@ -13621,26 +14005,708 @@ var IMGateway = class {
   }
 };
 
+// src/internal/repository/index.ts
+init_cjs_shims();
+
+// src/internal/repository/contact-repository.ts
+init_cjs_shims();
+var ApiContactRepository = class {
+  constructor(gateway) {
+    this.gateway = gateway;
+  }
+  gateway;
+  async getLinksContacts() {
+    return this.gateway.getLinksContacts();
+  }
+  invalidate() {
+  }
+  async sync() {
+  }
+  clear() {
+  }
+  async getStatus() {
+    return { count: 0, lastSyncAt: null };
+  }
+};
+var SqliteContactRepository = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async getLinksContacts() {
+    const rows = this.db.prepare(
+      "SELECT owner_uid, data, cached_at FROM contacts_cache ORDER BY cached_at DESC LIMIT 1"
+    ).all();
+    if (!rows || rows.length === 0) {
+      return fail("NOT_FOUND" /* NOT_FOUND */, "Contacts not found in cache");
+    }
+    return ok(JSON.parse(rows[0].data));
+  }
+  upsert(ownerUid, data) {
+    this.db.prepare("INSERT INTO contacts_cache (owner_uid, data, cached_at) VALUES (?, ?, ?)").run(ownerUid, JSON.stringify(data), Date.now());
+  }
+  invalidate() {
+    this.db.exec("DELETE FROM contacts_cache");
+  }
+  async sync() {
+  }
+  clear() {
+    this.db.exec("DELETE FROM contacts_cache");
+    this.db.exec("DELETE FROM cache_metadata WHERE key = 'last_sync_contacts'");
+  }
+  async getStatus() {
+    const count = this.db.prepare("SELECT COUNT(*) as c FROM contacts_cache").get();
+    const meta = this.db.prepare("SELECT value FROM cache_metadata WHERE key = 'last_sync_contacts'").get();
+    return {
+      count: count.c,
+      lastSyncAt: meta ? parseInt(meta.value, 10) : null
+    };
+  }
+};
+var CachedContactRepository = class {
+  constructor(local, remote, ttlMs = 5 * 60 * 1e3) {
+    this.local = local;
+    this.remote = remote;
+    this.ttlMs = ttlMs;
+  }
+  local;
+  remote;
+  ttlMs;
+  async getLinksContacts() {
+    const cached = await this.local.getLinksContacts();
+    if (cached.ok) {
+      const status = await this.local.getStatus();
+      if (status.lastSyncAt !== null && Date.now() - status.lastSyncAt < this.ttlMs) {
+        return cached;
+      }
+    }
+    const remote = await this.remote.getLinksContacts();
+    if (remote.ok) {
+      this.local.upsert("", remote.data);
+      this.local.db.prepare("INSERT OR REPLACE INTO cache_metadata (key, value) VALUES (?, ?)").run("last_sync_contacts", String(Date.now()));
+    }
+    return remote;
+  }
+  invalidate() {
+    this.local.invalidate();
+  }
+  async sync() {
+    const result = await this.remote.getLinksContacts();
+    if (result.ok) {
+      this.local.upsert("", result.data);
+      this.local.db.prepare("INSERT OR REPLACE INTO cache_metadata (key, value) VALUES (?, ?)").run("last_sync_contacts", String(Date.now()));
+    }
+  }
+  clear() {
+    this.local.clear();
+  }
+  async getStatus() {
+    return this.local.getStatus();
+  }
+};
+
+// src/internal/repository/conversation-repository.ts
+init_cjs_shims();
+var ApiConversationRepository = class {
+  constructor(gateway, imGateway) {
+    this.gateway = gateway;
+    this.imGateway = imGateway;
+  }
+  gateway;
+  imGateway;
+  async queryAll(options3) {
+    const result = await this.imGateway.queryConversations(options3);
+    if (result.status === "error") {
+      return fail(result.code, result.message);
+    }
+    return ok(result.data?.conversations ?? []);
+  }
+  async getProfile(conversationId, conversationType) {
+    return this.gateway.getProfileByConversationId(conversationId, conversationType);
+  }
+  async searchByUid(uid) {
+    const listResult = await this.imGateway.queryConversations({ limit: 0, offset: 0 });
+    if (listResult.status === "error") {
+      return fail(listResult.code, listResult.message);
+    }
+    const conversations3 = listResult.data?.conversations ?? [];
+    const results = [];
+    for (const conv of conversations3) {
+      const profileResult = await this.gateway.getProfileByConversationId(conv.id);
+      if (!profileResult.ok) continue;
+      const hasTarget = profileResult.data.users.some((u) => u.uid === uid);
+      if (hasTarget) {
+        results.push(profileResult.data);
+      }
+    }
+    return ok(results);
+  }
+  invalidate(_conversationId) {
+  }
+  async sync() {
+  }
+  clear() {
+  }
+  async getStatus() {
+    return { count: 0, lastSyncAt: null };
+  }
+};
+var SqliteConversationRepository = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  queryAll(_options) {
+    return Promise.resolve(ok([]));
+  }
+  getProfile(conversationId) {
+    const row = this.db.prepare("SELECT data FROM conversation_profiles WHERE conversation_id = ?").get(conversationId);
+    if (!row) {
+      return Promise.resolve(
+        fail("NOT_FOUND" /* NOT_FOUND */, "Conversation profile not found in cache")
+      );
+    }
+    return Promise.resolve(ok(JSON.parse(row.data)));
+  }
+  searchByUid(uid) {
+    const rows = this.db.prepare(
+      "SELECT data FROM conversation_profiles WHERE user_ids LIKE ? OR user_ids LIKE ? OR user_ids LIKE ? OR user_ids = ?"
+    ).all(`%${uid},%`, `%,${uid},%`, `%,${uid}`, uid);
+    const results = rows.map((r) => JSON.parse(r.data));
+    return Promise.resolve(ok(results));
+  }
+  upsertProfile(conversationId, profile) {
+    const user_ids = profile.users.map((u) => u.uid).join(",");
+    const cached_at = Date.now();
+    const data = JSON.stringify(profile);
+    this.db.prepare(
+      "INSERT INTO conversation_profiles (conversation_id, data, user_ids, cached_at) VALUES (?, ?, ?, ?) ON CONFLICT(conversation_id) DO UPDATE SET data=?, user_ids=?, cached_at=?"
+    ).run(conversationId, data, user_ids, cached_at, data, user_ids, cached_at);
+  }
+  invalidate(conversationId) {
+    this.db.prepare("DELETE FROM conversation_profiles WHERE conversation_id = ?").run(conversationId);
+  }
+  sync() {
+    return Promise.resolve();
+  }
+  clear() {
+    this.db.exec("DELETE FROM conversation_profiles");
+    this.db.exec("DELETE FROM cache_metadata WHERE key = 'last_sync_conversations'");
+  }
+  getStatus() {
+    const count = this.db.prepare("SELECT COUNT(*) as c FROM conversation_profiles").get();
+    const meta = this.db.prepare("SELECT value FROM cache_metadata WHERE key = 'last_sync_conversations'").get();
+    return Promise.resolve({
+      count: count.c,
+      lastSyncAt: meta ? parseInt(meta.value, 10) : null
+    });
+  }
+};
+var CachedConversationRepository = class {
+  constructor(local, remote) {
+    this.local = local;
+    this.remote = remote;
+  }
+  local;
+  remote;
+  syncInProgress = false;
+  async queryAll(options3) {
+    return this.remote.queryAll(options3);
+  }
+  async getProfile(conversationId, conversationType) {
+    const cached = await this.local.getProfile(conversationId);
+    if (cached.ok) return cached;
+    const remote = await this.remote.getProfile(conversationId, conversationType);
+    if (remote.ok) {
+      this.local.upsertProfile(conversationId, remote.data);
+    }
+    return remote;
+  }
+  async searchByUid(uid) {
+    const cached = await this.local.searchByUid(uid);
+    if (cached.ok && cached.data.length > 0) return cached;
+    await this.ensureSynced();
+    const retry = await this.local.searchByUid(uid);
+    return retry;
+  }
+  async ensureSynced() {
+    if (this.syncInProgress) return;
+    const status = await this.local.getStatus();
+    const isFresh = status.lastSyncAt !== null && Date.now() - status.lastSyncAt < 5 * 60 * 1e3;
+    if (isFresh) return;
+    this.syncInProgress = true;
+    try {
+      await this.sync();
+    } finally {
+      this.syncInProgress = false;
+    }
+  }
+  async sync() {
+    const convResult = await this.remote.queryAll({ limit: 0, offset: 0 });
+    if (!convResult.ok || !convResult.data) return;
+    for (const conv of convResult.data) {
+      const profileResult = await this.remote.getProfile(conv.id);
+      if (profileResult.ok) {
+        this.local.upsertProfile(conv.id, profileResult.data);
+      }
+    }
+    this.local.db.prepare("INSERT OR REPLACE INTO cache_metadata (key, value) VALUES (?, ?)").run("last_sync_conversations", String(Date.now()));
+  }
+  invalidate(conversationId) {
+    this.local.invalidate(conversationId);
+  }
+  clear() {
+    this.local.clear();
+  }
+  async getStatus() {
+    return this.local.getStatus();
+  }
+};
+
+// src/internal/repository/message-repository.ts
+init_cjs_shims();
+var ApiMessageRepository = class {
+  constructor(imGateway) {
+    this.imGateway = imGateway;
+  }
+  imGateway;
+  async pullMessages(conversationId, options3) {
+    const result = await this.imGateway.pullMessages(conversationId, options3);
+    if (result.status === "error") {
+      return fail(result.code, result.message);
+    }
+    return ok({
+      messages: result.data?.messages ?? [],
+      finished: result.data?.finished ?? true,
+      lastId: result.data?.lastId ?? ""
+    });
+  }
+  invalidate(_conversationId) {
+  }
+  async sync(_conversationId) {
+  }
+  clear() {
+  }
+};
+var SqliteMessageRepository = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async pullMessages(conversationId, options3) {
+    const limit = options3?.limit ?? 50;
+    const fromId = options3?.fromMessageId;
+    let sql = "SELECT message_id, data FROM messages_cache WHERE conversation_id = ?";
+    const params = [conversationId];
+    if (fromId) {
+      if (options3?.direction === "newer") {
+        sql += " AND message_id > ?";
+        params.push(fromId);
+      } else {
+        sql += " AND message_id < ?";
+        params.push(fromId);
+      }
+    }
+    sql += " ORDER BY message_id DESC LIMIT ?";
+    params.push(limit);
+    const rows = this.db.prepare(sql).all(...params);
+    if (rows.length === 0) {
+      return fail("NOT_FOUND" /* NOT_FOUND */, "Messages not found in cache");
+    }
+    return ok({
+      messages: rows.map((r) => JSON.parse(r.data)),
+      finished: rows.length < limit,
+      lastId: rows[rows.length - 1]?.message_id ?? ""
+    });
+  }
+  upsert(conversationId, messageId, data) {
+    this.db.prepare(
+      "INSERT INTO messages_cache (conversation_id, message_id, data, cached_at) VALUES (?, ?, ?, ?) ON CONFLICT(conversation_id, message_id) DO UPDATE SET data=?, cached_at=?"
+    ).run(
+      conversationId,
+      messageId,
+      JSON.stringify(data),
+      Date.now(),
+      JSON.stringify(data),
+      Date.now()
+    );
+  }
+  invalidate(conversationId) {
+    this.db.prepare("DELETE FROM messages_cache WHERE conversation_id = ?").run(conversationId);
+  }
+  async sync(_conversationId) {
+  }
+  clear() {
+    this.db.exec("DELETE FROM messages_cache");
+  }
+};
+var CachedMessageRepository = class {
+  constructor(local, remote) {
+    this.local = local;
+    this.remote = remote;
+  }
+  local;
+  remote;
+  async pullMessages(conversationId, options3) {
+    const cached = await this.local.pullMessages(conversationId, options3);
+    if (cached.ok) return cached;
+    const remote = await this.remote.pullMessages(conversationId, options3);
+    if (remote.ok) {
+      for (const msg of remote.data.messages) {
+        const messageId = msg.id;
+        if (messageId) {
+          this.local.upsert(conversationId, messageId, msg);
+        }
+      }
+    }
+    return remote;
+  }
+  invalidate(conversationId) {
+    this.local.invalidate(conversationId);
+  }
+  async sync(conversationId) {
+    const result = await this.remote.pullMessages(conversationId, { limit: 100 });
+    if (result.ok) {
+      for (const msg of result.data.messages) {
+        const messageId = msg.id;
+        if (messageId) {
+          this.local.upsert(conversationId, messageId, msg);
+        }
+      }
+    }
+  }
+  clear() {
+    this.local.clear();
+  }
+};
+
+// src/internal/repository/relation-repository.ts
+init_cjs_shims();
+var ApiRelationRepository = class {
+  constructor(gateway) {
+    this.gateway = gateway;
+  }
+  gateway;
+  async getLinkNameType(friendUid) {
+    return this.gateway.getLinkNameType(friendUid);
+  }
+  invalidate(_friendUid) {
+  }
+  async sync() {
+  }
+  clear() {
+  }
+};
+var SqliteRelationRepository = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async getLinkNameType(friendUid) {
+    const row = this.db.prepare("SELECT name, type, cached_at FROM relations_cache WHERE friend_uid = ?").get(friendUid);
+    if (!row) return fail("NOT_FOUND" /* NOT_FOUND */, "Relation not found in cache");
+    return ok({ name: row.name, type: row.type });
+  }
+  upsert(friendUid, name, type) {
+    this.db.prepare(
+      "INSERT OR REPLACE INTO relations_cache (friend_uid, name, type, cached_at) VALUES (?, ?, ?, ?)"
+    ).run(friendUid, name, type, Date.now());
+  }
+  invalidate(friendUid) {
+    this.db.prepare("DELETE FROM relations_cache WHERE friend_uid = ?").run(friendUid);
+  }
+  async sync() {
+  }
+  clear() {
+    this.db.exec("DELETE FROM relations_cache");
+  }
+};
+var CachedRelationRepository = class {
+  constructor(local, remote, ttlMs = 5 * 60 * 1e3) {
+    this.local = local;
+    this.remote = remote;
+    this.ttlMs = ttlMs;
+  }
+  local;
+  remote;
+  ttlMs;
+  async getLinkNameType(friendUid) {
+    const row = this.local.db.prepare("SELECT name, type, cached_at FROM relations_cache WHERE friend_uid = ?").get(friendUid);
+    if (row && Date.now() - row.cached_at < this.ttlMs) {
+      return ok({ name: row.name, type: row.type });
+    }
+    const remote = await this.remote.getLinkNameType(friendUid);
+    if (remote.ok) {
+      this.local.upsert(friendUid, remote.data.name, remote.data.type);
+    }
+    return remote;
+  }
+  invalidate(friendUid) {
+    this.local.invalidate(friendUid);
+  }
+  async sync() {
+  }
+  clear() {
+    this.local.clear();
+  }
+};
+
+// src/internal/repository/sqlite.ts
+init_cjs_shims();
+var import_node_path5 = require("path");
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+var SCHEMA_VERSION = 1;
+var CREATE_TABLES = `
+CREATE TABLE IF NOT EXISTS conversation_profiles (
+  conversation_id TEXT PRIMARY KEY,
+  data TEXT NOT NULL,
+  user_ids TEXT NOT NULL,
+  cached_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_conv_user_ids ON conversation_profiles(user_ids);
+
+CREATE TABLE IF NOT EXISTS contacts_cache (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  owner_uid TEXT NOT NULL,
+  data TEXT NOT NULL,
+  cached_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_contacts_owner ON contacts_cache(owner_uid);
+
+CREATE TABLE IF NOT EXISTS user_profiles (
+  uid TEXT PRIMARY KEY,
+  data TEXT NOT NULL,
+  cached_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS relations_cache (
+  friend_uid TEXT PRIMARY KEY,
+  name TEXT,
+  type INTEGER,
+  cached_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS messages_cache (
+  conversation_id TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  data TEXT NOT NULL,
+  cached_at INTEGER NOT NULL,
+  PRIMARY KEY (conversation_id, message_id)
+);
+CREATE INDEX IF NOT EXISTS idx_msg_conv ON messages_cache(conversation_id);
+
+CREATE TABLE IF NOT EXISTS cache_metadata (
+  key TEXT PRIMARY KEY,
+  value TEXT
+);
+`;
+function resolveDbPaths(configDir, uid) {
+  return {
+    dbFile: (0, import_node_path5.join)(configDir, `cache-${uid}.db`)
+  };
+}
+function openDatabase(dbPath) {
+  const db = new import_better_sqlite3.default(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(CREATE_TABLES);
+  ensureVersion(db);
+  return db;
+}
+function closeDatabase(db) {
+  db.close();
+}
+function ensureVersion(db) {
+  const row = db.prepare("SELECT value FROM cache_metadata WHERE key = 'schema_version'").get();
+  const current = row ? parseInt(row.value, 10) : 0;
+  if (current < SCHEMA_VERSION) {
+    db.prepare("INSERT OR REPLACE INTO cache_metadata (key, value) VALUES (?, ?)").run(
+      "schema_version",
+      String(SCHEMA_VERSION)
+    );
+  }
+}
+
+// src/internal/repository/user-repository.ts
+init_cjs_shims();
+var ApiUserRepository = class {
+  constructor(gateway) {
+    this.gateway = gateway;
+  }
+  gateway;
+  findUserById(id) {
+    return this.gateway.findUserById(id);
+  }
+  searchUserById(id) {
+    return this.gateway.searchUserById(id);
+  }
+  getUserAgentProfile(friendUid, agentId) {
+    return this.gateway.getUserAgentProfile(friendUid, agentId);
+  }
+  invalidate(_uid) {
+  }
+  async sync() {
+  }
+  clear() {
+  }
+};
+var SqliteUserRepository = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async findUserById(id) {
+    const row = this.db.prepare("SELECT data FROM user_profiles WHERE uid = ?").get(id);
+    if (!row) return fail("NOT_FOUND" /* NOT_FOUND */, "User not found in cache");
+    return ok(JSON.parse(row.data));
+  }
+  async searchUserById(id) {
+    const row = this.db.prepare("SELECT data FROM user_profiles WHERE uid = ?").get(id);
+    if (!row) return fail("NOT_FOUND" /* NOT_FOUND */, "User not found in cache");
+    const data = JSON.parse(row.data);
+    return ok({
+      id: data.id,
+      uid: data.uid,
+      nickname: data.nickname,
+      avatar: data.avatar,
+      agent: data.agent
+    });
+  }
+  async getUserAgentProfile(friendUid, _agentId) {
+    const row = this.db.prepare("SELECT data FROM user_profiles WHERE uid = ?").get(friendUid);
+    if (!row) return fail("NOT_FOUND" /* NOT_FOUND */, "User profile not found in cache");
+    return ok(JSON.parse(row.data));
+  }
+  upsert(uid, data) {
+    this.db.prepare("INSERT OR REPLACE INTO user_profiles (uid, data, cached_at) VALUES (?, ?, ?)").run(uid, JSON.stringify(data), Date.now());
+  }
+  invalidate(uid) {
+    this.db.prepare("DELETE FROM user_profiles WHERE uid = ?").run(uid);
+  }
+  async sync() {
+  }
+  clear() {
+    this.db.exec("DELETE FROM user_profiles");
+  }
+};
+var CachedUserRepository = class {
+  constructor(local, remote, ttlMs = 60 * 60 * 1e3) {
+    this.local = local;
+    this.remote = remote;
+    this.ttlMs = ttlMs;
+  }
+  local;
+  remote;
+  ttlMs;
+  async findUserById(id) {
+    return this.fetchWithCache(
+      id,
+      () => this.remote.findUserById(id),
+      (data) => this.local.upsert(id, data)
+    );
+  }
+  async searchUserById(id) {
+    return this.fetchWithCache(
+      id,
+      () => this.remote.searchUserById(id),
+      (data) => {
+        this.local.upsert(id, {
+          id: data.id,
+          uid: data.uid,
+          nickname: data.nickname,
+          avatar: data.avatar,
+          title: "",
+          link_type: 0,
+          sex: 0,
+          address: "",
+          status: 0,
+          agent: data.agent
+        });
+      }
+    );
+  }
+  async getUserAgentProfile(friendUid, agentId) {
+    return this.fetchWithCache(
+      friendUid,
+      () => this.remote.getUserAgentProfile(friendUid, agentId),
+      (data) => this.local.upsert(friendUid, data)
+    );
+  }
+  async fetchWithCache(uid, fetch2, store) {
+    const row = this.local.db.prepare("SELECT data, cached_at FROM user_profiles WHERE uid = ?").get(uid);
+    if (row && Date.now() - row.cached_at < this.ttlMs) {
+      return ok(JSON.parse(row.data));
+    }
+    const remote = await fetch2();
+    if (remote.ok) {
+      store(remote.data);
+    }
+    return remote;
+  }
+  invalidate(uid) {
+    this.local.invalidate(uid);
+  }
+  async sync() {
+  }
+  clear() {
+    this.local.clear();
+  }
+};
+
+// src/internal/repository/index.ts
+function createRepositories(configDir, uid, gateway, imGateway) {
+  const paths = resolveDbPaths(configDir, uid);
+  const db = openDatabase(paths.dbFile);
+  const sqliteConv = new SqliteConversationRepository(db);
+  const sqliteContact = new SqliteContactRepository(db);
+  const sqliteUser = new SqliteUserRepository(db);
+  const sqliteRelation = new SqliteRelationRepository(db);
+  const sqliteMessage = new SqliteMessageRepository(db);
+  const apiConv = new ApiConversationRepository(gateway, imGateway);
+  const apiContact = new ApiContactRepository(gateway);
+  const apiUser = new ApiUserRepository(gateway);
+  const apiRelation = new ApiRelationRepository(gateway);
+  const apiMessage = new ApiMessageRepository(imGateway);
+  const conversation = new CachedConversationRepository(sqliteConv, apiConv);
+  const contact = new CachedContactRepository(sqliteContact, apiContact);
+  const user = new CachedUserRepository(sqliteUser, apiUser);
+  const relation = new CachedRelationRepository(sqliteRelation, apiRelation);
+  const message = new CachedMessageRepository(sqliteMessage, apiMessage);
+  return {
+    conversation,
+    contact,
+    user,
+    relation,
+    message,
+    close: () => closeDatabase(db)
+  };
+}
+
 // src/factory.ts
 function createFactory(config) {
   const client = new APIClient(config.baseURL, config.debug);
   if (config.uid && config.tk && config.token) {
     client.setAuth({ uid: config.uid, tk: config.tk, token: config.token });
   }
+  const gateway = new ApiGateway(client);
+  const imGateway = new IMGateway({
+    wsUrl: config.wsURL,
+    cid: config.cid,
+    debugEnabled: config.debug
+  });
+  const configDir = getConfigDirectory(detectEnvironment());
+  const repos = createRepositories(configDir, config.uid ?? "anonymous", gateway, imGateway);
   return {
-    gateway: new ApiGateway(client),
-    imGateway: new IMGateway({
-      wsUrl: config.wsURL,
-      cid: config.cid,
-      debugEnabled: config.debug
-    }),
-    config
+    gateway,
+    imGateway,
+    config,
+    repos
   };
 }
 
 // src/cmd.ts
 var logDebugEnabled = false;
-var LocalizedHelp = class extends import_commander8.Help {
+var LocalizedHelp = class extends import_commander9.Help {
   /** Format an argument name with <required> or [optional] brackets. */
   argDisplayName(arg) {
     const name = arg.name() + (arg.variadic === true ? "..." : "");
@@ -13683,7 +14749,7 @@ async function main() {
   logDebugEnabled = config.debug;
   setLogDebug(config.debug);
   const factory = createFactory(config);
-  const program = new import_commander8.Command();
+  const program = new import_commander9.Command();
   const testModeBanner = `
 \u2554\u2550\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2550\u2557
 \u2551 DEVELOPMENT BUILD           \u2551
@@ -13694,7 +14760,7 @@ async function main() {
 ${t("cli.banner")}` : t("cli.banner");
   program.addHelpText("beforeAll", `${banner}
 `);
-  program.name("qz").version(`v${"0.2.1"}`, "-v, --version", t("options.version")).helpOption("-h, --help", t("options.help")).option("-q, --jq <expr>", t("options.jq")).option("--dry-run", t("options.dryRun"));
+  program.name("qz").version(`v${"0.3.0-rc.1"}`, "-v, --version", t("options.version")).helpOption("-h, --help", t("options.help")).option("-q, --jq <expr>", t("options.jq")).option("--dry-run", t("options.dryRun"));
   program.usage("<command> [subcommand] [options]");
   program.hook("preAction", () => {
     const opts = program.opts();
@@ -13704,6 +14770,7 @@ ${t("cli.banner")}` : t("cli.banner");
     factory.gateway.setDryRun(dryRun2);
     factory.imGateway.setDryRun(dryRun2);
   });
+  program.addCommand(NewCmdCache(factory));
   program.addCommand(NewCmdAuth(factory));
   program.addCommand(NewCmdConfig(factory));
   program.addCommand(NewCmdUser(factory));