@mcinteerj/openclaw-gmail 1.3.0 → 1.4.0

package/src/outbound-check.ts

@@ -1,10 +1,10 @@
 /**
  * Thread recipient validation for Gmail outbound.
- * 
+ *
  * Validates that thread reply recipients are permitted by allowOutboundTo.
  */
 
-import { spawn } from "node:child_process";
+import type { GmailClient } from "./gmail-client.js";
 
 export interface ThreadParticipant {
   email: string;
@@ -16,94 +16,9 @@ export interface ThreadData {
   originalSender: string | null;
 }
 
-/**
- * Fetch thread data (participants and original sender) in a single call.
- */
-export async function fetchThreadData(
-  threadId: string, 
-  accountEmail: string
-): Promise<ThreadData> {
-  return new Promise((resolve, reject) => {
-    const args = ["gmail", "thread", "get", threadId, "--json", "--account", accountEmail];
-    const proc = spawn("gog", args, { stdio: "pipe" });
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-
-    const timeout = setTimeout(() => {
-      if (!settled) {
-        settled = true;
-        proc.kill();
-        reject(new Error("Timeout fetching thread data"));
-      }
-    }, 10000);
-
-    const cleanup = () => {
-      clearTimeout(timeout);
-    };
-
-    proc.stdout.on("data", (d) => (stdout += d.toString()));
-    proc.stderr.on("data", (d) => (stderr += d.toString()));
-
-    proc.on("close", (code) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-
-      if (code !== 0) {
-        reject(new Error(`Failed to fetch thread: ${stderr}`));
-        return;
-      }
-
-      try {
-        const data = JSON.parse(stdout);
-        const messages = data.thread?.messages || [];
-        const participants = new Map<string, ThreadParticipant>();
-        let originalSender: string | null = null;
-
-        for (let i = 0; i < messages.length; i++) {
-          const msg = messages[i];
-          const headers = msg.payload?.headers || [];
-          
-          for (const header of headers) {
-            const name = header.name.toLowerCase();
-            if (["from", "to", "cc"].includes(name)) {
-              const addresses = parseEmailAddresses(header.value);
-              for (const addr of addresses) {
-                if (addr.email.toLowerCase() !== accountEmail.toLowerCase()) {
-                  participants.set(addr.email.toLowerCase(), addr);
-                }
-                
-                // Capture original sender from first message's From header
-                if (i === 0 && name === "from" && !originalSender) {
-                  originalSender = addr.email;
-                }
-              }
-            }
-          }
-        }
-
-        resolve({
-          participants: Array.from(participants.values()),
-          originalSender,
-        });
-      } catch (e) {
-        reject(new Error(`Failed to parse thread: ${e}`));
-      }
-    });
-
-    proc.on("error", (e) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      reject(new Error(`Failed to spawn gog: ${e.message}`));
-    });
-  });
-}
-
 /**
  * Parse email addresses from a header value like "Name <email>, Other <email2>"
- * 
+ *
  * Handles:
  * - Simple: email@example.com
  * - Named: Name <email@example.com>
@@ -113,20 +28,24 @@ export async function fetchThreadData(
 export function parseEmailAddresses(value: string): ThreadParticipant[] {
   const results: ThreadParticipant[] = [];
   if (!value || typeof value !== "string") return results;
-  
+
   // Split by comma, but respect quoted strings
   // This regex splits on commas that are NOT inside quotes
   const parts = value.split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/);
-  
+
   for (const part of parts) {
     const trimmed = part.trim();
     if (!trimmed) continue;
-    
+
     // Try to match "Name" <email> or Name <email>
-    const match = trimmed.match(/^(?:"?([^"<]*)"?\s*)?<([^>]+)>$/);
-    
+    // First pattern: quoted name with possible escaped quotes inside
+    // Second pattern: unquoted name
+    const match =
+      trimmed.match(/^"((?:[^"\\]|\\.)*?)"\s*<([^>]+)>$/) ||
+      trimmed.match(/^(?:([^"<]*)\s+)?<([^>]+)>$/);
+
     if (match) {
-      const name = match[1]?.trim().replace(/^"|"$/g, "");
+      const name = match[1]?.trim().replace(/\\"/g, '"');
       const email = match[2].trim().toLowerCase();
       if (email.includes("@")) {
         results.push({ name: name || undefined, email });
@@ -136,13 +55,13 @@ export function parseEmailAddresses(value: string): ThreadParticipant[] {
       results.push({ email: trimmed.toLowerCase() });
     }
   }
-  
+
   return results;
 }
 
 /**
  * Check if an email is allowed by the allowlist.
- * 
+ *
  * Rules:
  * - Empty list = no restriction (returns true)
  * - "*" in list = allow all
@@ -153,10 +72,10 @@ export function isEmailAllowed(email: string, allowList: string[]): boolean {
   // Empty list = no restriction
   if (allowList.length === 0) return true;
   if (allowList.includes("*")) return true;
-  
+
   if (!email) return false;
   const normalized = email.toLowerCase();
-  
+
   return allowList.some((entry) => {
     const e = entry.toLowerCase().trim();
     if (!e) return false;
@@ -173,9 +92,45 @@ export interface ValidationResult {
   reason?: string;
 }
 
+/**
+ * Extract ThreadData (participants + original sender) from thread messages.
+ * Replaces the old fetchThreadData() that spawned gog directly.
+ */
+function extractThreadData(
+  messages: { from: string; to?: string; cc?: string }[],
+  accountEmail: string,
+): ThreadData {
+  const participants = new Map<string, ThreadParticipant>();
+  let originalSender: string | null = null;
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    const fields: string[] = [msg.from, msg.to, msg.cc].filter(Boolean) as string[];
+
+    for (const field of fields) {
+      const addresses = parseEmailAddresses(field);
+      for (const addr of addresses) {
+        if (addr.email.toLowerCase() !== accountEmail.toLowerCase()) {
+          participants.set(addr.email.toLowerCase(), addr);
+        }
+
+        // Capture original sender from first message's From field
+        if (i === 0 && field === msg.from && !originalSender) {
+          originalSender = addr.email;
+        }
+      }
+    }
+  }
+
+  return {
+    participants: Array.from(participants.values()),
+    originalSender,
+  };
+}
+
 /**
  * Validate thread recipients against policy.
- * 
+ *
  * Policies:
  * - "open": Allow replies to anyone (default, backwards compatible)
  * - "allowlist": All recipients must be in allowOutboundTo
@@ -185,7 +140,8 @@ export async function validateThreadReply(
   threadId: string,
   accountEmail: string,
   allowOutboundTo: string[],
-  policy: "open" | "allowlist" | "sender-only"
+  policy: "open" | "allowlist" | "sender-only",
+  client: GmailClient,
 ): Promise<ValidationResult> {
   if (policy === "open") {
     return { ok: true };
@@ -193,7 +149,11 @@ export async function validateThreadReply(
 
   let threadData: ThreadData;
   try {
-    threadData = await fetchThreadData(threadId, accountEmail);
+    const thread = await client.getThread(threadId);
+    if (!thread) {
+      return { ok: false, reason: "Could not fetch thread data" };
+    }
+    threadData = extractThreadData(thread.messages, accountEmail);
   } catch (err) {
     console.error(`[gmail] Failed to fetch thread data for validation: ${err}`);
     return { ok: false, reason: `Could not fetch thread data: ${err}` };
@@ -204,15 +164,15 @@ export async function validateThreadReply(
       console.error(`[gmail] Could not determine original sender for thread ${threadId}`);
       return { ok: false, reason: "Could not determine thread sender" };
     }
-    
+
     if (!isEmailAllowed(threadData.originalSender, allowOutboundTo)) {
-      return { 
-        ok: false, 
-        blocked: [threadData.originalSender], 
-        reason: "Thread sender not in allowOutboundTo" 
+      return {
+        ok: false,
+        blocked: [threadData.originalSender],
+        reason: "Thread sender not in allowOutboundTo"
       };
     }
-    
+
     return { ok: true };
   }
 

package/src/outbound.ts

@@ -1,4 +1,3 @@
-import { spawn } from "node:child_process";
 import { marked } from "marked";
 import sanitizeHtml from "sanitize-html";
 import { type OutboundContext, type OpenClawConfig } from "openclaw/plugin-sdk";
@@ -7,74 +6,41 @@ import { isGmailThreadId } from "./normalize.js";
 import { fetchQuotedContext, type QuotedContent } from "./quoting.js";
 import { validateThreadReply, isEmailAllowed } from "./outbound-check.js";
 import type { GmailConfig } from "./config.js";
+import type { GmailClient } from "./gmail-client.js";
 
 export interface GmailOutboundContext extends OutboundContext {
   subject?: string;
   threadId?: string;
   replyToId?: string;
-}
-
-async function spawnGog(args: string[], retries = 3): Promise<void> {
-    for (let i = 0; i < retries; i++) {
-        try {
-            await new Promise<void>((resolve, reject) => {
-                const proc = spawn("gog", args, { stdio: "pipe" });
-                let err = "";
-                let out = "";
-                proc.stderr.on("data", (d) => err += d.toString());
-                proc.stdout.on("data", (d) => out += d.toString());
-                proc.on("error", (e) => reject(new Error(`gog failed to spawn: ${e.message}`)));
-                proc.on("close", (code) => {
-                    if (code === 0) resolve();
-                    else reject(new Error(`gog failed (code ${code}): ${err || out}`));
-                });
-
-                // Add a timeout
-                setTimeout(() => {
-                    proc.kill();
-                    reject(new Error("gog timed out after 30s"));
-                }, 30000);
-            });
-            return;
-        } catch (err) {
-            if (i === retries - 1) throw err;
-            await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
-        }
-    }
+  client: GmailClient;
 }
 
 export async function sendGmailText(ctx: GmailOutboundContext) {
-  const { to, text, accountId, cfg, threadId, replyToId, subject: explicitSubject } = ctx;
+  const { to, text, accountId, cfg, threadId, replyToId, subject: explicitSubject, client } = ctx;
   const account = resolveGmailAccount(cfg, accountId);
   const gmailCfg = cfg.channels?.gmail as GmailConfig | undefined;
-  
+
   // Validate we have a target - prioritize threadId if it's valid
   const effectiveThreadId = isGmailThreadId(String(threadId)) ? String(threadId) : undefined;
   const toValue = effectiveThreadId || to || "";
-  
+
   if (!toValue) {
     throw new Error("Gmail send requires a valid 'to' address or thread ID");
   }
 
-  const args = ["gmail", "send"];
-  
-  if (account.email) {
-      args.push("--account", account.email);
-  }
-
   // Determine if quoted replies are enabled (default: true)
   const accountCfg = gmailCfg?.accounts?.[accountId || "default"];
-  const includeQuotedReplies = accountCfg?.includeQuotedReplies 
-    ?? gmailCfg?.defaults?.includeQuotedReplies 
+  const includeQuotedReplies = accountCfg?.includeQuotedReplies
+    ?? gmailCfg?.defaults?.includeQuotedReplies
     ?? true;
 
   // Determine outbound restrictions
-  const allowOutboundTo = accountCfg?.allowOutboundTo 
-    ?? gmailCfg?.defaults?.allowOutboundTo 
-    ?? account.allowFrom 
+  const allowOutboundTo = accountCfg?.allowOutboundTo
+    ?? gmailCfg?.defaults?.allowOutboundTo
+    ?? account.allowFrom
     ?? [];
-  const threadReplyPolicy = accountCfg?.threadReplyPolicy 
-    ?? gmailCfg?.defaults?.threadReplyPolicy 
+  const threadReplyPolicy = accountCfg?.threadReplyPolicy
+    ?? gmailCfg?.defaults?.threadReplyPolicy
     ?? "open"; // Default: open for backwards compatibility
 
   const subject = explicitSubject || "(no subject)";
@@ -87,9 +53,10 @@ export async function sendGmailText(ctx: GmailOutboundContext) {
       toValue,
       account.email,
       allowOutboundTo,
-      threadReplyPolicy
+      threadReplyPolicy,
+      client,
     );
-    
+
     if (!validation.ok) {
       const blockedList = validation.blocked?.join(", ") || "unknown";
       throw new Error(
@@ -107,83 +74,70 @@ export async function sendGmailText(ctx: GmailOutboundContext) {
     }
   }
 
-  if (!isThread) {
-      args.push("--to", toValue);
-      args.push("--subject", subject);
-  } else {
-      // Reply to thread
-      if (replyToId) {
-          args.push("--reply-to-message-id", String(replyToId));
-      } else {
-          args.push("--thread-id", toValue);
-      }
-      
-      args.push("--subject", subject);
-      args.push("--reply-all");
-
-      // Fetch quoted thread context if enabled
-      if (includeQuotedReplies && account.email) {
-        try {
-          quotedContent = await fetchQuotedContext(
-            toValue,
-            account.email,
-            account.email
-          );
-        } catch (err) {
-          // Non-fatal: proceed without quoted context
-          console.error(`[gmail] Failed to fetch quoted context: ${err}`);
-        }
-      }
+  // Fetch quoted thread context if enabled
+  if (isThread && includeQuotedReplies && account.email) {
+    try {
+      quotedContent = await fetchQuotedContext(
+        toValue,
+        account.email,
+        client,
+      );
+    } catch (err) {
+      // Non-fatal: proceed without quoted context
+      console.error(`[gmail] Failed to fetch quoted context: ${err}`);
+    }
   }
 
   // Convert reply text to HTML (quotes are handled separately to avoid markdown mangling)
+  let fullHtml: string | undefined;
+  let plainBody = text;
+
   try {
-      const rawHtml = await marked.parse(text);
-      const replyHtml = sanitizeHtml(rawHtml, {
-          allowedTags: sanitizeHtml.defaults.allowedTags.concat(['img']),
-          allowedAttributes: {
-              ...sanitizeHtml.defaults.allowedAttributes,
-              '*': ['style', 'class']
-          }
-      });
-
-      // 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}`;
+    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", fullHtml);
-      args.push("--body", plainBody);
+    // Build Gmail-style blockquote HTML for the quoted content
+    fullHtml = replyHtml;
+    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}`;
+    }
   } catch (err) {
-      console.error("Markdown parsing or sanitization failed, sending plain text", err);
-      let plainBody = text;
-      if (quotedContent) {
-        plainBody = `${text}\n\n${quotedContent.header}\n\n${quotedContent.bodyPlain}`;
-      }
-      args.push("--body", plainBody);
+    console.error("Markdown parsing or sanitization failed, sending plain text", err);
+    if (quotedContent) {
+      plainBody = `${text}\n\n${quotedContent.header}\n\n${quotedContent.bodyPlain}`;
+    }
   }
 
-  await spawnGog(args);
+  await client.send({
+    account: account.email,
+    to: isThread ? undefined : toValue,
+    subject,
+    textBody: plainBody,
+    htmlBody: fullHtml,
+    threadId: isThread ? toValue : undefined,
+    replyToMessageId: replyToId ? String(replyToId) : undefined,
+    replyAll: 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");
-    
     // Best effort archive
-    spawnGog(archiveArgs).catch((err) => {
-        console.error(`Failed to archive thread ${toValue}: ${err.message}`);
+    client.modifyLabels(toValue, { remove: ["INBOX"] }).catch((err) => {
+      console.error(`Failed to archive thread ${toValue}: ${err instanceof Error ? err.message : String(err)}`);
     });
   }
 

package/src/quoting.ts

@@ -1,5 +1,5 @@
-import { spawn } from "node:child_process";
 import sanitizeHtml from "sanitize-html";
+import type { GmailClient } from "./gmail-client.js";
 
 export interface QuotedContent {
   header: string;        // "On Mon, Feb 22, 2026 at 2:15 PM, John Doe wrote:"
@@ -26,8 +26,8 @@ export interface ThreadResponse {
   messages: ThreadMessage[];
 }
 
-// Raw gog output types
-interface GogThreadOutput {
+// Raw gog output types — exported for use by GogGmailClient
+export interface GogThreadOutput {
   downloaded: unknown;
   thread: {
     id: string;
@@ -36,7 +36,7 @@ interface GogThreadOutput {
   };
 }
 
-interface GogRawMessage {
+export interface GogRawMessage {
   id: string;
   threadId: string;
   internalDate: string;
@@ -114,59 +114,18 @@ function parseGogMessage(raw: GogRawMessage): ThreadMessage {
 }
 
 /**
- * Fetch thread data from gog CLI
+ * Parse raw gog thread JSON into a ThreadResponse.
+ * Extracted from fetchThread() so GogGmailClient can reuse it.
  */
-async function fetchThread(threadId: string, account?: string): Promise<ThreadResponse | null> {
-  const args = ["gmail", "thread", "get", threadId, "--full", "--json"];
-  if (account) {
-    args.push("--account", account);
-  }
-
-  return new Promise((resolve) => {
-    const proc = spawn("gog", args, { stdio: "pipe" });
-    let stdout = "";
-    let stderr = "";
-
-    proc.stdout.on("data", (d) => (stdout += d.toString()));
-    proc.stderr.on("data", (d) => (stderr += d.toString()));
-
-    proc.on("error", (e) => {
-      console.error(`[gmail] Failed to spawn gog for thread fetch: ${e.message}`);
-      resolve(null);
-    });
-
-    proc.on("close", (code) => {
-      if (code !== 0) {
-        console.error(`[gmail] gog thread get failed (code ${code}): ${stderr}`);
-        resolve(null);
-        return;
-      }
-      try {
-        const parsed = JSON.parse(stdout) as GogThreadOutput;
-        // gog wraps the thread in { downloaded, thread }
-        const thread = parsed.thread;
-        if (!thread || !thread.messages) {
-          resolve(null);
-          return;
-        }
-        resolve({
-          id: thread.id,
-          historyId: thread.historyId,
-          messages: thread.messages.map(parseGogMessage),
-        });
-      } catch (e) {
-        console.error(`[gmail] Failed to parse thread JSON: ${e}`);
-        resolve(null);
-      }
-    });
-
-    // Timeout after 15s
-    setTimeout(() => {
-      proc.kill();
-      console.error(`[gmail] gog thread get timed out`);
-      resolve(null);
-    }, 15000);
-  });
+export function parseGogThreadOutput(data: unknown): ThreadResponse | null {
+  const parsed = data as GogThreadOutput;
+  const thread = parsed?.thread;
+  if (!thread || !thread.messages) return null;
+  return {
+    id: thread.id,
+    historyId: thread.historyId,
+    messages: thread.messages.map(parseGogMessage),
+  };
 }
 
 /**
@@ -267,9 +226,9 @@ export function buildQuotedThread(
 export async function fetchQuotedContext(
   threadId: string,
   accountEmail: string,
-  accountArg?: string
+  client: GmailClient,
 ): Promise<QuotedContent | null> {
-  const thread = await fetchThread(threadId, accountArg);
+  const thread = await client.getThread(threadId, { full: true });
   if (!thread || !thread.messages || thread.messages.length === 0) {
     return null;
   }