@mcinteerj/openclaw-gmail 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcinteerj/openclaw-gmail",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Gmail channel plugin for OpenClaw - direct API or gog CLI",
   "type": "module",
   "main": "index.ts",

package/src/accounts.ts

@@ -18,12 +18,36 @@ export interface ResolvedGmailAccount extends ResolvedChannelAccount {
   };
 }
 
+/**
+ * Normalize an account key the same way the gateway's routing layer does
+ * (replace non-alphanumeric chars with hyphens). This allows matching
+ * "honk-keithy-gmail-com" back to "honk.keithy@gmail.com".
+ */
+function canonicalizeKey(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+
 export function resolveGmailAccount(
   cfg: ChannelConfig<GmailConfig>,
   accountId?: string,
 ): ResolvedGmailAccount {
   const resolvedId = accountId || DEFAULT_ACCOUNT_ID;
-  const account = cfg.channels?.['openclaw-gmail']?.accounts?.[resolvedId];
+  const accounts = cfg.channels?.['openclaw-gmail']?.accounts;
+  let account = accounts?.[resolvedId];
+
+  // If direct lookup fails, try matching against canonicalized account keys.
+  // The gateway's routing layer normalizes email-format accountIds (e.g.
+  // "honk.keithy@gmail.com" -> "honk-keithy-gmail-com"), so we need to
+  // reverse-match by canonicalizing each config key the same way.
+  if (!account && accounts && resolvedId !== DEFAULT_ACCOUNT_ID) {
+    const canonicalizedId = canonicalizeKey(resolvedId);
+    for (const key of Object.keys(accounts)) {
+      if (canonicalizeKey(key) === canonicalizedId) {
+        account = accounts[key];
+        break;
+      }
+    }
+  }
 
   if (!account) {
     // Graceful fallback for UI logic that queries 'default' on unconfigured channels

package/src/api-client.ts

@@ -85,25 +85,46 @@ export class ApiGmailClient implements GmailClient {
     if (!thread || thread.messages.length === 0) return null;
 
     const lastMsg = thread.messages[thread.messages.length - 1];
+    const selfLower = selfEmail.toLowerCase();
 
-    // Resolve To: reply to the sender of the last message
-    const to = lastMsg.from;
+    // Determine if the last message is from self
+    const fromAddresses = parseEmailAddresses(lastMsg.from);
+    const lastMsgIsFromSelf = fromAddresses.some(
+      (a) => a.email.toLowerCase() === selfLower,
+    );
+
+    // Resolve To:
+    // - If last message is from someone else: reply to that sender (standard reply)
+    // - If last message is from self: reply to the recipients of that message (matches Gmail client)
+    let to: string;
+    if (lastMsgIsFromSelf) {
+      to = lastMsg.to || "";
+    } else {
+      to = lastMsg.from;
+    }
 
-    // For reply-all, Cc = everyone from To + Cc minus self and the new To
+    // For reply-all, build CC from the last message's To + CC, minus self and the new To
     let cc: string | undefined;
     if (replyAll) {
-      const selfLower = selfEmail.toLowerCase();
       const toAddresses = parseEmailAddresses(to);
-      const toLower = new Set(toAddresses.map((a) => a.email.toLowerCase()));
+      const seen = new Set(toAddresses.map((a) => a.email.toLowerCase()));
+      seen.add(selfLower); // always exclude self
 
       const ccCandidates: string[] = [];
-      for (const field of [lastMsg.to, lastMsg.cc]) {
+
+      // When replying to own message: lastMsg.to is already the new To, so CC from lastMsg.cc only
+      // When replying to other's message: lastMsg.from is the new To, so CC from lastMsg.to + lastMsg.cc
+      const ccSources = lastMsgIsFromSelf
+        ? [lastMsg.cc]
+        : [lastMsg.to, lastMsg.cc];
+
+      for (const field of ccSources) {
         if (!field) continue;
         const addresses = parseEmailAddresses(field);
         for (const addr of addresses) {
-          if (addr.email.toLowerCase() !== selfLower && !toLower.has(addr.email.toLowerCase())) {
+          if (!seen.has(addr.email.toLowerCase())) {
             ccCandidates.push(addr.name ? `${addr.name} <${addr.email}>` : addr.email);
-            toLower.add(addr.email.toLowerCase()); // dedupe
+            seen.add(addr.email.toLowerCase()); // dedupe
           }
         }
       }

package/src/outbound.ts

@@ -43,10 +43,26 @@ export async function sendGmailText(ctx: GmailOutboundContext) {
     ?? gmailCfg?.defaults?.threadReplyPolicy
     ?? "open"; // Default: open for backwards compatibility
 
-  const subject = explicitSubject || "(no subject)";
   const isThread = isGmailThreadId(toValue);
   let quotedContent: QuotedContent | null = null;
 
+  // Resolve subject: use explicit, or look up from thread, or fallback
+  let subject = explicitSubject;
+  if (!subject && isThread) {
+    try {
+      const thread = await client.getThread(toValue, { full: false });
+      if (thread && thread.messages.length > 0) {
+        const origSubject = thread.messages[0].subject;
+        if (origSubject) {
+          subject = origSubject.toLowerCase().startsWith("re:") ? origSubject : `Re: ${origSubject}`;
+        }
+      }
+    } catch {
+      // Non-fatal: fall through to default
+    }
+  }
+  subject = subject || "(no subject)";
+
   // Validate outbound recipients
   if (isThread && threadReplyPolicy !== "open" && account.email) {
     const validation = await validateThreadReply(
@@ -119,7 +135,7 @@ export async function sendGmailText(ctx: GmailOutboundContext) {
     }
   }
 
-  await client.send({
+  const sendParams = {
     account: account.email,
     to: isThread ? undefined : toValue,
     subject,
@@ -128,7 +144,8 @@ export async function sendGmailText(ctx: GmailOutboundContext) {
     threadId: isThread ? toValue : undefined,
     replyToMessageId: replyToId ? String(replyToId) : undefined,
     replyAll: isThread,
-  });
+  };
+  await client.send(sendParams);
 
   // Archive if it was a thread (Reply = Archive), unless disabled by config
   const archiveOnReply = accountCfg?.archiveOnReply