@qzhuli/qzhuli-cli 0.5.3 → 0.5.5

package/dist/cmd.js

@@ -12302,37 +12302,46 @@ 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
-        };
+  try {
+    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();
     }
-  } else {
-    factory.repos.conversation.clear();
-    factory.repos.contact.clear();
-    factory.repos.user.clear();
-    factory.repos.relation.clear();
-    factory.repos.message.clear();
+  } catch (error) {
+    return {
+      status: "error",
+      code: "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+      message: error instanceof Error ? error.message : "Failed to clear cache",
+      data: null
+    };
   }
   return {
     status: "success",
@@ -12345,25 +12354,34 @@ async function cacheClearRun(factory, opts) {
 // 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"
+  try {
+    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"
+        }
       }
-    }
-  };
+    };
+  } catch (error) {
+    return {
+      status: "error",
+      code: "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+      message: error instanceof Error ? error.message : "Failed to read cache status",
+      data: null
+    };
+  }
 }
 
 // src/commands/cache/sync.ts
@@ -12727,11 +12745,24 @@ async function searchByName(factory, name) {
   const profileResults = await Promise.all(
     conversations3.map((c) => factory.repos.conversation.getProfile(c.id))
   );
-  const matchedProfiles = profileResults.filter((r) => r.ok).map((r) => r.data).filter((p) => {
+  const queryLower = name.toLowerCase();
+  const scored = profileResults.filter((r) => r.ok).flatMap((r) => {
+    const p = r.data;
     const convName = p.conversation.name ?? "";
-    return convName.includes(name);
-  });
-  if (matchedProfiles.length === 0) {
+    const teamName = p.conversation.team_name ?? "";
+    const fields = [convName, teamName].filter(Boolean);
+    if (fields.length === 0) return [];
+    let best = 0;
+    for (const f of fields) {
+      const lower = f.toLowerCase();
+      if (lower === queryLower) best = Math.max(best, 3);
+      else if (lower.startsWith(queryLower)) best = Math.max(best, 2);
+      else if (lower.includes(queryLower)) best = Math.max(best, 1);
+    }
+    if (best === 0) return [];
+    return [{ profile: p, score: best }];
+  }).sort((a, b) => b.score - a.score);
+  if (scored.length === 0) {
     return {
       status: "success",
       code: "NOT_FOUND" /* NOT_FOUND */,
@@ -12739,7 +12770,7 @@ async function searchByName(factory, name) {
       data: null
     };
   }
-  const items = matchedProfiles.map(profileToItem);
+  const items = scored.map((s) => profileToItem(s.profile));
   const groupedByUid = /* @__PURE__ */ new Map();
   for (const item of items) {
     const primaryUser = item.users[0];
@@ -12757,7 +12788,19 @@ async function searchByName(factory, name) {
       });
     }
   }
-  const results = [...groupedByUid.values()];
+  const results = [...groupedByUid.values()].sort((a, b) => {
+    const maxScoreA = Math.max(
+      ...a.conversations.map(
+        (c) => scored.find((s) => s.profile.conversation.conversation_id === c.conversationId)?.score ?? 0
+      )
+    );
+    const maxScoreB = Math.max(
+      ...b.conversations.map(
+        (c) => scored.find((s) => s.profile.conversation.conversation_id === c.conversationId)?.score ?? 0
+      )
+    );
+    return maxScoreB - maxScoreA;
+  });
   if (results.length === 0) {
     return {
       status: "success",
@@ -12846,6 +12889,14 @@ async function friendListRun(factory) {
 
 // src/commands/friend/profile.ts
 init_cjs_shims();
+function matchScore(text, queryLower) {
+  if (!text) return 0;
+  const lower = text.toLowerCase();
+  if (lower === queryLower) return 3;
+  if (lower.startsWith(queryLower)) return 2;
+  if (lower.includes(queryLower)) return 1;
+  return 0;
+}
 async function friendProfileRun(factory, opts) {
   const listResult = await factory.repos.contact.getLinksContacts();
   if (!listResult.ok) {
@@ -12886,17 +12937,17 @@ async function friendProfileRun(factory, opts) {
       friend_name: team.name
     }))
   ];
-  const query = opts.query.toLowerCase();
-  const matches = allEntries.filter((e) => {
-    if (opts.byUid) {
-      return e.uid?.toLowerCase() === query;
-    }
-    if (opts.byRemark) {
-      return e.friend_name?.toLowerCase() === query;
-    }
-    return e.nickname?.toLowerCase().includes(query);
-  });
-  if (matches.length === 0) {
+  const queryLower = opts.query.toLowerCase();
+  let scored;
+  if (opts.byUid) {
+    scored = allEntries.filter((e) => e.uid?.toLowerCase() === queryLower).map((e) => ({ ...e, score: 3 }));
+  } else {
+    scored = allEntries.map((e) => {
+      const field = opts.byRemark ? e.friend_name : e.nickname;
+      return { ...e, score: matchScore(field, queryLower) };
+    }).filter((e) => e.score > 0).sort((a, b) => b.score - a.score);
+  }
+  if (scored.length === 0) {
     return {
       status: "error",
       code: "NOT_FOUND" /* NOT_FOUND */,
@@ -12904,12 +12955,13 @@ async function friendProfileRun(factory, opts) {
       data: null
     };
   }
-  if (matches.length > 1) {
-    const suggestions = matches.map((m) => ({
+  if (scored.length > 1) {
+    const suggestions = scored.map((m) => ({
       uid: m.uid,
       nickname: m.nickname ?? "",
       remark: m.friend_name ?? "",
-      type: m._type
+      type: m._type,
+      score: m.score
     }));
     return {
       status: "needs_resolution",
@@ -12918,12 +12970,12 @@ async function friendProfileRun(factory, opts) {
       data: suggestions
     };
   }
-  const match = matches[0];
+  const match = scored[0];
   if (match._type !== "link") {
     return {
       status: "success",
       code: "USER_FOUND" /* USER_FOUND */,
-      message: t("messages.found").replace("{name}", match.nickname ?? match.friend_name),
+      message: t("messages.found").replace("{name}", match.nickname ?? match.friend_name ?? ""),
       data: {
         uid: match.uid,
         nickname: match.nickname ?? match.friend_name,
@@ -14335,33 +14387,53 @@ var SqliteContactRepository = class {
     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");
+    try {
+      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));
+    } catch (error) {
+      return fail(
+        "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+        error instanceof Error ? error.message : "Failed to read contacts from 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());
+    try {
+      this.db.prepare("INSERT INTO contacts_cache (owner_uid, data, cached_at) VALUES (?, ?, ?)").run(ownerUid, JSON.stringify(data), Date.now());
+    } catch {
+    }
   }
   invalidate() {
-    this.db.exec("DELETE FROM contacts_cache");
+    try {
+      this.db.exec("DELETE FROM contacts_cache");
+    } catch {
+    }
   }
   async sync() {
   }
   clear() {
-    this.db.exec("DELETE FROM contacts_cache");
-    this.db.exec("DELETE FROM cache_metadata WHERE key = 'last_sync_contacts'");
+    try {
+      this.db.exec("DELETE FROM contacts_cache");
+      this.db.exec("DELETE FROM cache_metadata WHERE key = 'last_sync_contacts'");
+    } catch {
+    }
   }
   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
-    };
+    try {
+      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
+      };
+    } catch {
+      return { count: 0, lastSyncAt: null };
+    }
   }
 };
 var CachedContactRepository = class {
@@ -14374,17 +14446,23 @@ var CachedContactRepository = class {
   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;
+    try {
+      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;
+        }
       }
+    } catch {
     }
     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()));
+      try {
+        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()));
+      } catch {
+      }
     }
     return remote;
   }
@@ -14394,8 +14472,11 @@ var CachedContactRepository = class {
   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()));
+      try {
+        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()));
+      } catch {
+      }
     }
   }
   clear() {
@@ -14461,38 +14542,62 @@ var SqliteConversationRepository = class {
     return Promise.resolve(ok([]));
   }
   getProfile(conversationId) {
-    const row = this.db.prepare("SELECT data FROM conversation_profiles WHERE conversation_id = ?").get(conversationId);
-    if (!row) {
+    try {
+      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)));
+    } catch (error) {
       return Promise.resolve(
-        fail("NOT_FOUND" /* NOT_FOUND */, "Conversation profile not found in cache")
+        fail(
+          "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+          error instanceof Error ? error.message : "Failed to read conversation from 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));
+    try {
+      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));
+    } catch (error) {
+      return Promise.resolve(
+        fail(
+          "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+          error instanceof Error ? error.message : "Failed to search conversations in cache"
+        )
+      );
+    }
   }
   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);
+    try {
+      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);
+    } catch {
+    }
   }
   // MARK: Conversation Index (for incremental sync)
   upsertIndex(conv) {
-    const members = JSON.stringify(conv.cids);
-    const nicks = conv.nicks ? JSON.stringify(conv.nicks) : null;
-    const im_version = conv.version;
-    const cached_at = Date.now();
-    this.db.prepare(
-      "INSERT INTO conversations_index (conversation_id, im_version, members, nicks, cached_at) VALUES (?, ?, ?, ?, ?) ON CONFLICT(conversation_id) DO UPDATE SET im_version=?, members=?, nicks=?, cached_at=?"
-    ).run(conv.id, im_version, members, nicks, cached_at, im_version, members, nicks, cached_at);
+    try {
+      const members = JSON.stringify(conv.cids);
+      const nicks = conv.nicks ? JSON.stringify(conv.nicks) : null;
+      const im_version = conv.version;
+      const cached_at = Date.now();
+      this.db.prepare(
+        "INSERT INTO conversations_index (conversation_id, im_version, members, nicks, cached_at) VALUES (?, ?, ?, ?, ?) ON CONFLICT(conversation_id) DO UPDATE SET im_version=?, members=?, nicks=?, cached_at=?"
+      ).run(conv.id, im_version, members, nicks, cached_at, im_version, members, nicks, cached_at);
+    } catch {
+    }
   }
   getIndexById(conversationId) {
     return this.db.prepare(
@@ -14500,34 +14605,51 @@ var SqliteConversationRepository = class {
     ).get(conversationId);
   }
   getAllIds() {
-    const rows = this.db.prepare("SELECT conversation_id FROM conversations_index").all();
-    return rows.map((r) => r.conversation_id);
+    try {
+      const rows = this.db.prepare("SELECT conversation_id FROM conversations_index").all();
+      return rows.map((r) => r.conversation_id);
+    } catch {
+      return [];
+    }
   }
   deleteStale(conversationIds) {
-    if (conversationIds.length === 0) return;
-    const placeholders = conversationIds.map(() => "?").join(",");
-    this.db.prepare(`DELETE FROM conversation_profiles WHERE conversation_id NOT IN (${placeholders})`).run(...conversationIds);
-    this.db.prepare(`DELETE FROM conversations_index WHERE conversation_id NOT IN (${placeholders})`).run(...conversationIds);
+    try {
+      if (conversationIds.length === 0) return;
+      const placeholders = conversationIds.map(() => "?").join(",");
+      this.db.prepare(`DELETE FROM conversation_profiles WHERE conversation_id NOT IN (${placeholders})`).run(...conversationIds);
+      this.db.prepare(`DELETE FROM conversations_index WHERE conversation_id NOT IN (${placeholders})`).run(...conversationIds);
+    } catch {
+    }
   }
   invalidate(conversationId) {
-    this.db.prepare("DELETE FROM conversation_profiles WHERE conversation_id = ?").run(conversationId);
-    this.db.prepare("DELETE FROM conversations_index WHERE conversation_id = ?").run(conversationId);
+    try {
+      this.db.prepare("DELETE FROM conversation_profiles WHERE conversation_id = ?").run(conversationId);
+      this.db.prepare("DELETE FROM conversations_index WHERE conversation_id = ?").run(conversationId);
+    } catch {
+    }
   }
   sync() {
     return Promise.resolve();
   }
   clear() {
-    this.db.exec("DELETE FROM conversation_profiles");
-    this.db.exec("DELETE FROM conversations_index");
-    this.db.exec("DELETE FROM cache_metadata WHERE key = 'last_sync_conversations'");
+    try {
+      this.db.exec("DELETE FROM conversation_profiles");
+      this.db.exec("DELETE FROM conversations_index");
+      this.db.exec("DELETE FROM cache_metadata WHERE key = 'last_sync_conversations'");
+    } catch {
+    }
   }
   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
-    });
+    try {
+      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
+      });
+    } catch {
+      return Promise.resolve({ count: 0, lastSyncAt: null });
+    }
   }
 };
 var CachedConversationRepository = class {
@@ -14634,50 +14756,66 @@ var SqliteMessageRepository = class {
     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);
+    try {
+      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 ?? ""
+      });
+    } catch (error) {
+      return fail(
+        "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+        error instanceof Error ? error.message : "Failed to read messages from cache"
+      );
     }
-    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()
-    );
+    try {
+      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()
+      );
+    } catch {
+    }
   }
   invalidate(conversationId) {
-    this.db.prepare("DELETE FROM messages_cache WHERE conversation_id = ?").run(conversationId);
+    try {
+      this.db.prepare("DELETE FROM messages_cache WHERE conversation_id = ?").run(conversationId);
+    } catch {
+    }
   }
   async sync(_conversationId) {
   }
   clear() {
-    this.db.exec("DELETE FROM messages_cache");
+    try {
+      this.db.exec("DELETE FROM messages_cache");
+    } catch {
+    }
   }
 };
 var CachedMessageRepository = class {
@@ -14743,22 +14881,38 @@ var SqliteRelationRepository = class {
     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 });
+    try {
+      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 });
+    } catch (error) {
+      return fail(
+        "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+        error instanceof Error ? error.message : "Failed to read relation from cache"
+      );
+    }
   }
   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());
+    try {
+      this.db.prepare(
+        "INSERT OR REPLACE INTO relations_cache (friend_uid, name, type, cached_at) VALUES (?, ?, ?, ?)"
+      ).run(friendUid, name, type, Date.now());
+    } catch {
+    }
   }
   invalidate(friendUid) {
-    this.db.prepare("DELETE FROM relations_cache WHERE friend_uid = ?").run(friendUid);
+    try {
+      this.db.prepare("DELETE FROM relations_cache WHERE friend_uid = ?").run(friendUid);
+    } catch {
+    }
   }
   async sync() {
   }
   clear() {
-    this.db.exec("DELETE FROM relations_cache");
+    try {
+      this.db.exec("DELETE FROM relations_cache");
+    } catch {
+    }
   }
 };
 var CachedRelationRepository = class {
@@ -14771,13 +14925,19 @@ var CachedRelationRepository = class {
   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 });
+    try {
+      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 });
+      }
+    } catch {
     }
     const remote = await this.remote.getLinkNameType(friendUid);
     if (remote.ok) {
-      this.local.upsert(friendUid, remote.data.name, remote.data.type);
+      try {
+        this.local.upsert(friendUid, remote.data.name, remote.data.type);
+      } catch {
+      }
     }
     return remote;
   }
@@ -14904,37 +15064,67 @@ var SqliteUserRepository = class {
     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));
+    try {
+      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));
+    } catch (error) {
+      return fail(
+        "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+        error instanceof Error ? error.message : "Failed to read user from cache"
+      );
+    }
   }
   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
-    });
+    try {
+      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
+      });
+    } catch (error) {
+      return fail(
+        "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+        error instanceof Error ? error.message : "Failed to search user in cache"
+      );
+    }
   }
   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));
+    try {
+      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));
+    } catch (error) {
+      return fail(
+        "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+        error instanceof Error ? error.message : "Failed to read user profile from cache"
+      );
+    }
   }
   upsert(uid, data) {
-    this.db.prepare("INSERT OR REPLACE INTO user_profiles (uid, data, cached_at) VALUES (?, ?, ?)").run(uid, JSON.stringify(data), Date.now());
+    try {
+      this.db.prepare("INSERT OR REPLACE INTO user_profiles (uid, data, cached_at) VALUES (?, ?, ?)").run(uid, JSON.stringify(data), Date.now());
+    } catch {
+    }
   }
   invalidate(uid) {
-    this.db.prepare("DELETE FROM user_profiles WHERE uid = ?").run(uid);
+    try {
+      this.db.prepare("DELETE FROM user_profiles WHERE uid = ?").run(uid);
+    } catch {
+    }
   }
   async sync() {
   }
   clear() {
-    this.db.exec("DELETE FROM user_profiles");
+    try {
+      this.db.exec("DELETE FROM user_profiles");
+    } catch {
+    }
   }
 };
 var CachedUserRepository = class {
@@ -14981,13 +15171,19 @@ var CachedUserRepository = class {
     );
   }
   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));
+    try {
+      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));
+      }
+    } catch (error) {
     }
     const remote = await fetch2();
     if (remote.ok) {
-      store(remote.data);
+      try {
+        store(remote.data);
+      } catch {
+      }
     }
     return remote;
   }
@@ -15109,7 +15305,7 @@ async function main() {
 ${t("cli.banner")}` : t("cli.banner");
   program.addHelpText("beforeAll", `${banner}
 `);
-  program.name("qz").version(`v${"0.5.3"}`, "-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.5.5"}`, "-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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qzhuli/qzhuli-cli",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "CLI tool for Q助理 (QZhuli)",
   "main": "dist/cmd.js",
   "bin": {

package/skills/qzhuli-cli/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: qzhuli-cli
 description: Use when operating the QZhuli CLI (`qz`), including login, auth status, config, friends, relations, users, conversations, messages, cache management, JSON filtering, dry-run, command help, and interpreting test-environment banners or config files.
-version: 0.1.2
+version: 0.1.3
 ---
 
 # QZhuli CLI
@@ -127,6 +127,7 @@ qz --jq ".data" conversation list --limit 5
 | Get conversation profile             | `qz conversation profile <conversation-id> [--type <n>]`                                      |
 | Create conversation                  | `qz conversation create <uid> --agent-id <id>`                                                |
 | Search conversations (ID)            | `qz conversation search <conversation-id>`                                                    |
+| Search conversations (CID)           | `qz conversation search <cid> --cid`                                                          |
 | Search conversations (name)          | `qz conversation search <name> --name`                                                        |
 | Search conversations (Q助号)           | `qz conversation search <q-number> --qnumber`                                                 |
 | Search conversations (UID)           | `qz conversation search <uid> --uid`                                                          |
@@ -165,6 +166,7 @@ Relation type values: `0=stranger`, `1=friend`, `2=family`, `3=colleague`.
 
 ```bash
 qz conversation search <conversation-id>           # default: by conversation ID
+qz conversation search <cid> --cid                 # by user CID
 qz conversation search <name> --name               # by conversation name
 qz conversation search <q-number> --qnumber        # by user Q助号
 qz conversation search <uid> --uid                 # by user UID