@pmate/cli 0.24.43 → 0.25.0

package/dist/index.js

@@ -16179,8 +16179,7 @@ var CollectCommandHandler = class {
       if (!thread) {
         throw new Error(`Thread not found: ${args.thread}`);
       }
-      await this.openThreadForReply(targetPage, thread);
-      await this.sendReplyText(targetPage, args.text);
+      await this.sendReplyViaConversation(targetPage, thread, args.text);
       ui.success("im1 reply sent", { source: target.sourceKey, thread: thread.name });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -16413,47 +16412,14 @@ var CollectCommandHandler = class {
       await session.detach().catch(() => void 0);
     }
   }
-  async openThreadForReply(page, thread) {
-    const opened = await this.evaluateInPage(
+  async sendReplyViaConversation(page, thread, text) {
+    const result = await this.evaluateInPage(
       page,
-      buildOpenConversationExpr(thread.conversationId)
-    ).catch((error) => ({
-      ok: false,
-      reason: error instanceof Error ? error.message : String(error)
-    }));
-    if (!opened.ok) {
-      await page.getByText(thread.name, { exact: true }).first().click({ timeout: 5e3 });
-    }
-    await page.waitForTimeout(500);
-  }
-  async sendReplyText(page, text) {
-    const selectors = [
-      '[data-testid="CompositionInput"]',
-      '[aria-label="Message"]',
-      '[aria-label="Write a message"]',
-      '[contenteditable="true"]',
-      "textarea"
-    ];
-    let focused = false;
-    for (const selector of selectors) {
-      const locator = page.locator(selector).last();
-      if (await locator.count().catch(() => 0) === 0) {
-        continue;
-      }
-      await locator.click({ timeout: 3e3 }).catch(() => void 0);
-      focused = await locator.evaluate((element) => {
-        const activeElement = element.ownerDocument?.activeElement;
-        return activeElement === element || element.contains(activeElement);
-      }).catch(() => false);
-      if (focused) {
-        break;
-      }
-    }
-    if (!focused) {
-      throw new Error("Cannot focus CC message composer.");
+      buildSendMessageExpr(thread.conversationId, text)
+    );
+    if (!result?.ok) {
+      throw new Error(result?.reason || "Send failed");
     }
-    await page.keyboard.insertText(text);
-    await page.keyboard.press("Enter");
   }
 };
 async function archiveMessageImages(rootDir, sourceKey, threadKey, messages2) {
@@ -16708,31 +16674,168 @@ function buildGetMessagesByConversationExpr(conversationId, limit) {
     }
   })()`;
 }
-function buildOpenConversationExpr(conversationId) {
+function buildSendMessageExpr(conversationId, message) {
   const escapedConversationId = escapeForJs(conversationId);
+  const escapedMessage = escapeForJs(message);
   return `(async function() {
     try {
-      var runtime = globalThis;
-      var controller = runtime.ConversationController;
-      var conversationId = '${escapedConversationId}';
-      var conversation = controller && typeof controller.get === 'function' ? controller.get(conversationId) : null;
-      if (!conversation) return { ok: false, reason: 'Conversation not found: ' + conversationId };
-      if (runtime.reduxActions && runtime.reduxActions.conversations) {
-        var actions = runtime.reduxActions.conversations;
-        if (typeof actions.showConversation === 'function') {
-          await actions.showConversation({ conversationId: conversationId });
-          return { ok: true };
+      var controller = globalThis.ConversationController;
+      if (!controller || typeof controller.get !== 'function') {
+        return { ok: false, reason: 'ConversationController unavailable' };
+      }
+      var conversation = controller.get('${escapedConversationId}');
+      if (!conversation) return { ok: false, reason: 'Conversation not found: ${escapedConversationId}' };
+      if (typeof conversation.sendMessage !== 'function') {
+        return { ok: false, reason: 'Conversation sendMessage unavailable' };
+      }
+      var type = conversation.get ? conversation.get('type') : null;
+      var name = conversation.get ? (conversation.get('name') || conversation.get('id')) : '${escapedConversationId}';
+      function normalizeMentionName(value) {
+        return String(value || '')
+          .replace(/\\s+/g, ' ')
+          .replace(/\\u200B/g, '')
+          .trim();
+      }
+      function addLookup(lookup, name, id) {
+        var normalized = normalizeMentionName(name);
+        if (!normalized || !id || lookup[normalized]) return;
+        lookup[normalized] = id;
+      }
+      function addMentionAliases(lookup, name, id) {
+        var normalized = normalizeMentionName(name);
+        addLookup(lookup, normalized, id);
+        addLookup(lookup, normalized.replace(/\\s*\\([^)]*\\)\\s*$/g, ''), id);
+        addLookup(lookup, normalized.replace(/\\s*\\[[^\\]]*\\]\\s*$/g, ''), id);
+        addLookup(lookup, normalized.replace(/\\s*[\uFF08][^\uFF09]*[\uFF09]\\s*$/g, ''), id);
+      }
+      function buildMentionLookup() {
+        var lookup = {};
+        var all = [];
+        if (controller && typeof controller.getAllPrivateConversations === 'function') {
+          var privates = controller.getAllPrivateConversations();
+          all = privates.models || privates || [];
+        }
+        for (var i = 0; i < all.length; i++) {
+          var contact = all[i];
+          var id = normalizeMentionName(contact && contact.get ? contact.get('id') : contact && contact.id);
+          if (!id) continue;
+          addMentionAliases(lookup, contact && contact.get ? contact.get('name') : contact && contact.name, id);
+          addMentionAliases(lookup, contact && contact.get ? contact.get('profileName') : contact && contact.profileName, id);
+          addMentionAliases(lookup, contact && contact.get ? contact.get('title') : contact && contact.title, id);
+        }
+        return lookup;
+      }
+      function normalizeMentionKey(value) {
+        return normalizeMentionName(value)
+          .replace(/^@+/, '')
+          .replace(/\\s*\\([^)]*\\)\\s*$/g, '')
+          .replace(/\\s*\\[[^\\]]*\\]\\s*$/g, '')
+          .replace(/\\s*[\uFF08][^\uFF09]*[\uFF09]\\s*$/g, '')
+          .toLowerCase()
+          .replace(/[^\\p{L}\\p{N}]+/gu, ' ')
+          .trim();
+      }
+      function hasWordBoundary(text, end) {
+        return end >= text.length || !/[\\p{L}\\p{N}_]/u.test(text[end]);
+      }
+      function readMentionQuery(text, atIndex) {
+        var start = atIndex + 1;
+        var end = start;
+        while (end < text.length && /[\\p{L}\\p{N}_-]/u.test(text[end])) {
+          end += 1;
+        }
+        if (end === start) return null;
+        return { raw: text.slice(start, end), start: atIndex, end: end };
+      }
+      function resolveFuzzyMention(query, lookup) {
+        var queryKey = normalizeMentionKey(query);
+        if (!queryKey) return null;
+        var scoresByUid = {};
+        var aliases = Object.keys(lookup);
+        for (var i = 0; i < aliases.length; i++) {
+          var alias = aliases[i];
+          var aliasKey = normalizeMentionKey(alias);
+          if (!aliasKey) continue;
+          var score = 0;
+          var aliasTokens = aliasKey.split(' ');
+          if (aliasKey === queryKey) score = 100;
+          else if (aliasTokens.indexOf(queryKey) !== -1) score = 80;
+          else if (aliasKey.indexOf(queryKey) !== -1) score = 60;
+          else if (queryKey.indexOf(aliasKey) !== -1) score = 40;
+          if (score === 0) continue;
+          var uid = lookup[alias];
+          if (!scoresByUid[uid] || score > scoresByUid[uid]) {
+            scoresByUid[uid] = score;
+          }
         }
-        if (typeof actions.conversationOpened === 'function') {
-          await actions.conversationOpened({ conversationId: conversationId });
-          return { ok: true };
+        var bestUid = null;
+        var bestScore = 0;
+        var bestCount = 0;
+        var uids = Object.keys(scoresByUid);
+        for (var j = 0; j < uids.length; j++) {
+          var uidScore = scoresByUid[uids[j]];
+          if (uidScore > bestScore) {
+            bestUid = uids[j];
+            bestScore = uidScore;
+            bestCount = 1;
+          } else if (uidScore === bestScore) {
+            bestCount += 1;
+          }
         }
+        return bestUid && bestCount === 1 ? bestUid : null;
       }
-      if (typeof conversation.trigger === 'function') {
-        conversation.trigger('opened', conversation);
-        return { ok: true };
+      function extractMentions(text) {
+        var lookup = buildMentionLookup();
+        var names = Object.keys(lookup).sort(function(a, b) { return b.length - a.length; });
+        var mentions = [];
+        var occupied = [];
+        function overlaps(start, end) {
+          for (var i = 0; i < occupied.length; i++) {
+            if (start < occupied[i].end && end > occupied[i].start) return true;
+          }
+          return false;
+        }
+        var atIndex = 0;
+        while (atIndex < text.length) {
+          var idx = text.indexOf('@', atIndex);
+          if (idx === -1) break;
+          if (overlaps(idx, idx + 1)) {
+            atIndex = idx + 1;
+            continue;
+          }
+          var matched = null;
+          for (var i = 0; i < names.length; i++) {
+            var mentionText = '@' + names[i];
+            if (text.slice(idx, idx + mentionText.length) === mentionText && hasWordBoundary(text, idx + mentionText.length)) {
+              matched = { uid: lookup[names[i]], start: idx, end: idx + mentionText.length };
+              break;
+            }
+          }
+          if (!matched) {
+            var query = readMentionQuery(text, idx);
+            if (query) {
+              var fuzzyUid = resolveFuzzyMention(query.raw, lookup);
+              if (fuzzyUid) {
+                matched = { uid: fuzzyUid, start: query.start, end: query.end };
+              }
+            }
+          }
+          if (matched && !overlaps(matched.start, matched.end)) {
+            mentions.push({ uid: matched.uid, start: matched.start, length: matched.end - matched.start, type: 0 });
+            occupied.push({ start: matched.start, end: matched.end });
+            atIndex = matched.end;
+          } else {
+            atIndex = idx + 1;
+          }
+        }
+        mentions.sort(function(a, b) { return a.start - b.start; });
+        return mentions;
       }
-      return { ok: false, reason: 'No supported conversation open API found' };
+      var mentions = extractMentions('${escapedMessage}');
+      var mentionTarget = mentions.length > 0 ? mentions[0].uid : null;
+      var mentionsArg = mentions.length > 0 ? mentions : null;
+      await conversation.sendMessage('${escapedMessage}', mentionTarget, mentionsArg, [], null, null, null, null, null, null);
+      return { ok: true, name: name, type: type, mentionCount: mentions.length };
     } catch(e) {
       return { ok: false, reason: e && e.message ? e.message : String(e) };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/cli",
-  "version": "0.24.43",
+  "version": "0.25.0",
   "description": "CLI utilities for the pMate project",
   "license": "MIT",
   "bin": {