@mcinteerj/openclaw-gmail 1.2.8 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcinteerj/openclaw-gmail",
-  "version": "1.2.8",
+  "version": "1.3.1",
   "description": "Gmail channel plugin for OpenClaw - uses gog CLI for secure Gmail access",
   "type": "module",
   "main": "index.ts",

package/src/channel.ts

@@ -10,7 +10,7 @@ import {
   type ChannelGatewayContext,
   type MsgContext,
 } from "openclaw/plugin-sdk";
-import { GmailConfigSchema } from "./config.js";
+import { GmailConfigSchema, type GmailConfig } from "./config.js";
 import {
   resolveGmailAccount,
   resolveDefaultGmailAccountId,
@@ -65,7 +65,7 @@ function buildGmailMsgContext(
     CommandBody: msg.text,
     From: msg.sender.id,
     To: to,
-    SessionKey: `gmail:${account.email}:${msg.threadId}`,
+    SessionKey: `agent:main:gmail:${account.email}:${msg.threadId}`,
     AccountId: msg.accountId,
     ChatType: "direct",
     ConversationLabel: threadLabel,
@@ -84,7 +84,7 @@ function buildGmailMsgContext(
     MediaUrl: msg.mediaUrl,
     CommandAuthorized: false,
     OriginatingChannel: "gmail" as const,
-    OriginatingTo: to,
+    OriginatingTo: msg.threadId,
   });
 
   return ctx;
@@ -104,6 +104,7 @@ async function dispatchGmailMessage(
       
       // Build the dispatch context
       const ctxPayload = buildGmailMsgContext(msg, account, cfg);
+      const gmailCfg = cfg.channels?.gmail as GmailConfig | undefined;
 
       // Build reply dispatcher options using gateway's reply capability
       const deliver = async (payload: { text: string }) => {
@@ -139,6 +140,12 @@ async function dispatchGmailMessage(
             log?.error(`[gmail][${requestId}] ${info.kind} reply failed: ${String(err)}`);
           },
         },
+        replyOptions: {
+          disableBlockStreaming:
+            typeof gmailCfg?.blockStreaming === "boolean"
+              ? !gmailCfg.blockStreaming
+              : true, // Default: disabled for email
+        },
       });
       log?.info(`[gmail][${requestId}] Dispatch complete for ${msg.channelMessageId}`);
     } catch (e: unknown) {
@@ -155,6 +162,7 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
   meta: {
     ...meta,
     id: "openclaw-gmail",
+    aliases: ["gmail"],
     showConfigured: true,
   },
   capabilities: {
@@ -167,6 +175,7 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
       type: "object",
       properties: {
         enabled: { type: "boolean", default: true },
+        blockStreaming: { type: "boolean", default: false },
         accounts: {
           type: "object",
           additionalProperties: {
@@ -178,6 +187,7 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
               allowFrom: { type: "array", items: { type: "string" } },
               historyId: { type: "string" },
               delegate: { type: "string" },
+              archiveOnReply: { type: "boolean", default: true },
             },
             required: ["email"],
           },
@@ -186,6 +196,7 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
           type: "object",
           properties: {
             allowFrom: { type: "array", items: { type: "string" } },
+            archiveOnReply: { type: "boolean", default: true },
           },
         },
       },

package/src/config.ts

@@ -15,16 +15,19 @@ export const GmailAccountSchema = z.object({
   // Outbound restrictions (security)
   allowOutboundTo: z.array(z.string()).optional(), // Who we can SEND to (if not set, falls back to allowFrom)
   threadReplyPolicy: z.enum(["open", "allowlist", "sender-only"]).optional(), // Default: "open" for backwards compat
+  archiveOnReply: z.boolean().optional(), // Archive thread after reply (default: true)
 });
 
 export const GmailConfigSchema = z.object({
   enabled: z.boolean().default(true),
+  blockStreaming: z.boolean().optional(), // Enable block streaming for email (default: false — emails send as one message)
   accounts: z.record(GmailAccountSchema).optional(),
   defaults: z.object({
     allowFrom: z.array(z.string()).optional(),
     includeQuotedReplies: z.boolean().default(true), // Global default for quoted replies
     allowOutboundTo: z.array(z.string()).optional(), // Global default for outbound allowlist
     threadReplyPolicy: z.enum(["open", "allowlist", "sender-only"]).optional(), // Global default
+    archiveOnReply: z.boolean().optional(), // Global default for archive on reply (default: true)
   }).optional(),
 });
 

package/src/outbound.ts

@@ -4,7 +4,7 @@ import sanitizeHtml from "sanitize-html";
 import { type OutboundContext, type OpenClawConfig } from "openclaw/plugin-sdk";
 import { resolveGmailAccount } from "./accounts.js";
 import { isGmailThreadId } from "./normalize.js";
-import { fetchQuotedContext } from "./quoting.js";
+import { fetchQuotedContext, type QuotedContent } from "./quoting.js";
 import { validateThreadReply, isEmailAllowed } from "./outbound-check.js";
 import type { GmailConfig } from "./config.js";
 
@@ -77,11 +77,9 @@ export async function sendGmailText(ctx: GmailOutboundContext) {
     ?? gmailCfg?.defaults?.threadReplyPolicy 
     ?? "open"; // Default: open for backwards compatibility
 
-  // Build the body, potentially with quoted thread context
-  let body = text;
   const subject = explicitSubject || "(no subject)";
-
   const isThread = isGmailThreadId(toValue);
+  let quotedContent: QuotedContent | null = null;
 
   // Validate outbound recipients
   if (isThread && threadReplyPolicy !== "open" && account.email) {
@@ -123,17 +121,14 @@ export async function sendGmailText(ctx: GmailOutboundContext) {
       args.push("--subject", subject);
       args.push("--reply-all");
 
-      // Fetch and append quoted thread context if enabled
+      // Fetch quoted thread context if enabled
       if (includeQuotedReplies && account.email) {
         try {
-          const quotedContext = await fetchQuotedContext(
+          quotedContent = await fetchQuotedContext(
             toValue,
             account.email,
             account.email
           );
-          if (quotedContext) {
-            body = `${text}\n\n${quotedContext}`;
-          }
         } catch (err) {
           // Non-fatal: proceed without quoted context
           console.error(`[gmail] Failed to fetch quoted context: ${err}`);
@@ -141,27 +136,47 @@ export async function sendGmailText(ctx: GmailOutboundContext) {
       }
   }
 
-  // Convert body to HTML and sanitize
+  // Convert reply text to HTML (quotes are handled separately to avoid markdown mangling)
   try {
-      const rawHtml = await marked.parse(body);
-      const cleanHtml = sanitizeHtml(rawHtml, {
+      const rawHtml = await marked.parse(text);
+      const replyHtml = sanitizeHtml(rawHtml, {
           allowedTags: sanitizeHtml.defaults.allowedTags.concat(['img']),
           allowedAttributes: {
               ...sanitizeHtml.defaults.allowedAttributes,
               '*': ['style', 'class']
           }
       });
-      args.push("--body-html", cleanHtml);
-      args.push("--body", body);
+
+      // Build Gmail-style blockquote HTML for the quoted content
+      let fullHtml = replyHtml;
+      let plainBody = text;
+      if (quotedContent) {
+        fullHtml += `<div class="gmail_quote">` +
+          `<div dir="ltr" class="gmail_attr">${sanitizeHtml(quotedContent.header, { allowedTags: [], allowedAttributes: {} })}</div>` +
+          `<blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">` +
+          `${quotedContent.bodyHtml}` +
+          `</blockquote></div>`;
+        plainBody = `${text}\n\n${quotedContent.header}\n\n${quotedContent.bodyPlain}`;
+      }
+
+      args.push("--body-html", fullHtml);
+      args.push("--body", plainBody);
   } catch (err) {
       console.error("Markdown parsing or sanitization failed, sending plain text", err);
-      args.push("--body", body);
+      let plainBody = text;
+      if (quotedContent) {
+        plainBody = `${text}\n\n${quotedContent.header}\n\n${quotedContent.bodyPlain}`;
+      }
+      args.push("--body", plainBody);
   }
 
   await spawnGog(args);
 
-  // Archive if it was a thread (Reply = Archive)
-  if (isThread) {
+  // Archive if it was a thread (Reply = Archive), unless disabled by config
+  const archiveOnReply = accountCfg?.archiveOnReply
+    ?? gmailCfg?.defaults?.archiveOnReply
+    ?? true;
+  if (isThread && archiveOnReply) {
     const archiveArgs = ["gmail", "labels", "modify", toValue];
     if (account.email) archiveArgs.push("--account", account.email);
     archiveArgs.push("--remove", "INBOX");

package/src/quoting.ts

@@ -1,4 +1,11 @@
 import { spawn } from "node:child_process";
+import sanitizeHtml from "sanitize-html";
+
+export interface QuotedContent {
+  header: string;        // "On Mon, Feb 22, 2026 at 2:15 PM, John Doe wrote:"
+  bodyHtml: string;      // Sanitized HTML from original message
+  bodyPlain: string;     // Plain text from original message (with > prefix)
+}
 
 export interface ThreadMessage {
   id: string;
@@ -9,6 +16,7 @@ export interface ThreadMessage {
   cc?: string;
   subject: string;
   body: string;
+  bodyHtml: string;
   labels: string[];
 }
 
@@ -67,6 +75,22 @@ function extractBody(msg: GogRawMessage): string {
   return "";
 }
 
+/**
+ * Extract HTML body from gog message
+ */
+function extractHtmlBody(msg: GogRawMessage): string {
+  if (msg.payload.parts) {
+    const htmlPart = msg.payload.parts.find((p) => p.mimeType === "text/html");
+    if (htmlPart?.body?.data) {
+      return Buffer.from(htmlPart.body.data, "base64").toString("utf-8");
+    }
+  }
+  if (msg.payload.body?.data) {
+    return Buffer.from(msg.payload.body.data, "base64").toString("utf-8");
+  }
+  return "";
+}
+
 /**
  * Convert gog raw message to our ThreadMessage format
  */
@@ -75,6 +99,7 @@ function parseGogMessage(raw: GogRawMessage): ThreadMessage {
   const date = getHeader(raw, "Date") || new Date(parseInt(raw.internalDate)).toISOString();
   const subject = getHeader(raw, "Subject") || "";
   const body = extractBody(raw);
+  const bodyHtml = extractHtmlBody(raw);
 
   return {
     id: raw.id,
@@ -83,6 +108,7 @@ function parseGogMessage(raw: GogRawMessage): ThreadMessage {
     from,
     subject,
     body,
+    bodyHtml,
     labels: raw.labelIds || [],
   };
 }
@@ -176,21 +202,37 @@ function extractSenderDisplay(from: string): string {
 }
 
 /**
- * Include message body as-is (flat, no ">" prefix to avoid staggered indentation)
+ * Prefix each line with "> " for plain text quoting
  */
 function quoteBody(body: string): string {
-  return body;
+  return body.split("\n").map((line) => `> ${line}`).join("\n");
+}
+
+/**
+ * Sanitize HTML for safe embedding in a blockquote.
+ * Preserves formatting (bold, links, lists) while removing dangerous content.
+ */
+function sanitizeQuoteHtml(html: string): string {
+  return sanitizeHtml(html, {
+    allowedTags: sanitizeHtml.defaults.allowedTags.concat(["img", "span", "div", "br", "hr"]),
+    allowedAttributes: {
+      ...sanitizeHtml.defaults.allowedAttributes,
+      "*": ["style", "class", "dir"],
+    },
+  });
 }
 
 /**
  * Build quoted context from the most recent non-self message.
  * Gmail standard: only quote the last message (which itself contains older quotes).
  * This avoids nested/staggered quoting.
+ *
+ * Returns structured QuotedContent for separate HTML and plain text rendering.
  */
 export function buildQuotedThread(
   messages: ThreadMessage[],
   accountEmail: string
-): string {
+): QuotedContent | null {
   // Filter out messages from the account itself
   const otherMessages = messages.filter((msg) => {
     const emailMatch = msg.from.match(/<(.*)>/);
@@ -199,7 +241,7 @@ export function buildQuotedThread(
   });
 
   if (otherMessages.length === 0) {
-    return "";
+    return null;
   }
 
   // Only quote the most recent message from others (last in array = newest)
@@ -207,23 +249,29 @@ export function buildQuotedThread(
   const sender = extractSenderDisplay(lastMsg.from);
   const date = formatQuoteDate(lastMsg.date);
   const header = `On ${date}, ${sender} wrote:`;
-  const quoted = quoteBody(lastMsg.body.trim());
 
-  return `${header}\n\n${quoted}`;
+  // HTML: sanitize original HTML body, fall back to plain text
+  const rawHtml = lastMsg.bodyHtml || lastMsg.body;
+  const bodyHtml = sanitizeQuoteHtml(rawHtml);
+
+  // Plain text: prefix each line with >
+  const bodyPlain = quoteBody(lastMsg.body.trim());
+
+  return { header, bodyHtml, bodyPlain };
 }
 
 /**
  * Fetch and format quoted context for a thread reply.
- * Returns the formatted quote block or empty string if unavailable.
+ * Returns structured QuotedContent or null if unavailable.
  */
 export async function fetchQuotedContext(
   threadId: string,
   accountEmail: string,
   accountArg?: string
-): Promise<string> {
+): Promise<QuotedContent | null> {
   const thread = await fetchThread(threadId, accountArg);
   if (!thread || !thread.messages || thread.messages.length === 0) {
-    return "";
+    return null;
   }
 
   return buildQuotedThread(thread.messages, accountEmail);