@mcinteerj/openclaw-gmail 1.3.0 → 1.4.0

package/src/channel.ts

@@ -21,27 +21,27 @@ import { setGmailRuntime, getGmailRuntime } from "./runtime.js";
 import { sendGmailText, type GmailOutboundContext } from "./outbound.js";
 import { gmailThreading } from "./threading.js";
 import { normalizeGmailTarget, isGmailThreadId, isAllowed } from "./normalize.js";
-import { parseInboundGmail, type GogPayload } from "./inbound.js";
-import { monitorGmail, quarantineMessage } from "./monitor.js";
-import { extractAttachments } from "./attachments.js";
+import { monitorGmail } from "./monitor.js";
 import { Semaphore } from "./semaphore.js";
+import { createGmailClient, type GmailClient } from "./gmail-client.js";
 import crypto from "node:crypto";
 
 const meta = {
   id: "gmail",
   label: "Gmail",
-  selectionLabel: "Gmail (gog)",
+  selectionLabel: "Gmail",
   detailLabel: "Gmail",
   docsPath: "/channels/gmail",
   docsLabel: "gmail",
-  blurb: "Uses gog for secure Gmail access.",
+  blurb: "Gmail integration via direct API or gog CLI.",
   systemImage: "envelope",
   order: 100,
   showConfigured: true,
 };
 
-// Map to store active account contexts
+// Map to store active account contexts and their clients
 const activeAccounts = new Map<string, ChannelGatewayContext<ResolvedGmailAccount>>();
+const activeClients = new Map<string, GmailClient>();
 
 // Limit concurrent dispatches to avoid memory spikes
 const dispatchSemaphore = new Semaphore(5);
@@ -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;
@@ -93,6 +93,7 @@ function buildGmailMsgContext(
 async function dispatchGmailMessage(
   ctx: ChannelGatewayContext<ResolvedGmailAccount>,
   msg: InboundMessage,
+  client: GmailClient,
 ) {
   const { account, accountId, cfg, log } = ctx;
   const runtime = getGmailRuntime();
@@ -101,7 +102,7 @@ async function dispatchGmailMessage(
   await dispatchSemaphore.run(async () => {
     try {
       log?.info(`[gmail][${requestId}] Dispatching message ${msg.channelMessageId} from ${msg.sender.id}`);
-      
+
       // Build the dispatch context
       const ctxPayload = buildGmailMsgContext(msg, account, cfg);
       const gmailCfg = cfg.channels?.gmail as GmailConfig | undefined;
@@ -109,10 +110,10 @@ async function dispatchGmailMessage(
       // Build reply dispatcher options using gateway's reply capability
       const deliver = async (payload: { text: string }) => {
         const originalSubject = msg.raw?.subject ||
-                               msg.raw?.headers?.subject || 
+                               msg.raw?.headers?.subject ||
                                msg.raw?.payload?.headers?.find((h: any) => h.name.toLowerCase() === "subject")?.value;
-        
-        const replySubject = originalSubject 
+
+        const replySubject = originalSubject
           ? (originalSubject.toLowerCase().startsWith("re:") ? originalSubject : `Re: ${originalSubject}`)
           : "Re: ";
 
@@ -124,6 +125,7 @@ async function dispatchGmailMessage(
           threadId: msg.threadId,
           replyToId: msg.channelMessageId,
           subject: replySubject,
+          client,
         });
       };
 
@@ -188,6 +190,16 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
               historyId: { type: "string" },
               delegate: { type: "string" },
               archiveOnReply: { type: "boolean", default: true },
+              backend: { type: "string", enum: ["gog", "api"] },
+              oauth: {
+                type: "object",
+                properties: {
+                  clientId: { type: "string" },
+                  clientSecret: { type: "string" },
+                  refreshToken: { type: "string" },
+                },
+                required: ["clientId", "clientSecret", "refreshToken"],
+              },
             },
             required: ["email"],
           },
@@ -237,7 +249,12 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
   outbound: {
     deliveryMode: "gateway",
     textChunkLimit: 8000,
-    sendText: sendGmailText,
+    sendText: (ctx: any) => {
+      const account = resolveGmailAccount(ctx.cfg, ctx.accountId);
+      const emailKey = account.email?.toLowerCase();
+      const client = (emailKey && activeClients.get(emailKey)) || createGmailClient(account, ctx.cfg);
+      return sendGmailText({ ...ctx, client });
+    },
     resolveTarget: ({ to, allowFrom }) => {
       const trimmed = to?.trim() ?? "";
       const normalized = normalizeGmailTarget(trimmed);
@@ -300,8 +317,10 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
         "### Attachments",
         "- **Location**: All attachments are stored in \`.attachments/{{threadId}}/\` relative to your workspace.",
         "- **Auto-Download**: Files under 5MB are already there. The message text contains their paths.",
-        "- **Manual Download**: For larger files (listed with an ID), download them to that same folder:",
-        `- Command: \`mkdir -p .attachments/{{threadId}} && gog gmail attachment <messageId> <attachmentId> --account ${account.email} --out .attachments/{{threadId}}/<filename>\``,
+        "- **Manual Download**: For larger files (listed with an ID), download them to that same folder.",
+        ...(account.backend === "api"
+          ? ["- The attachment download tool is available as part of the Gmail API client."]
+          : [`- Command: \`mkdir -p .attachments/{{threadId}} && gog gmail attachment <messageId> <attachmentId> --account ${account.email} --out .attachments/{{threadId}}/<filename>\``]),
       ];
     },
   },
@@ -310,15 +329,19 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
     supportsAction: ({ action }: { action: string }) => action === "send",
     handleAction: async (ctx: any) => {
       if (ctx.action !== "send") return { ok: false, error: new Error(`Unsupported action: ${ctx.action}`) };
-      
+
       const { params, accountId, cfg, toolContext } = ctx;
+      const account = resolveGmailAccount(cfg, accountId);
+      const emailKey = account.email?.toLowerCase();
+      const client = (emailKey && activeClients.get(emailKey)) || createGmailClient(account, cfg);
+
       const to = (params.target || params.to) as string;
       const text = params.message as string;
-      
+
       const isThread = isGmailThreadId(to);
       let subject = params.subject as string | undefined;
       let replyToId: string | undefined;
-      
+
       if (isThread && toolContext?.currentThreadTs) {
           replyToId = toolContext.currentThreadTs;
       }
@@ -331,8 +354,9 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
         threadId: isThread ? to : undefined,
         replyToId,
         subject,
+        client,
       });
-      
+
       return { ok: true, content: [{ type: "text", text: "Message sent via Gmail." }] };
     },
   },
@@ -340,8 +364,12 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
     startAccount: async (ctx) => {
       ctx.log?.info(`[gmail] Account ${ctx.account.accountId} started`);
 
-      if (ctx.account.email) {
-        activeAccounts.set(ctx.account.email.toLowerCase(), ctx);
+      const client = createGmailClient(ctx.account, ctx.cfg);
+      const emailKey = ctx.account.email?.toLowerCase();
+
+      if (emailKey) {
+        activeAccounts.set(emailKey, ctx);
+        activeClients.set(emailKey, client);
       }
 
       ctx.setStatus({ accountId: ctx.accountId, running: true, connected: true });
@@ -355,11 +383,12 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
       await monitorGmail({
         account: ctx.account,
         onMessage: async (msg) => {
-          await dispatchGmailMessage(ctx, msg);
+          await dispatchGmailMessage(ctx, msg, client);
         },
         signal,
         log: ctx.log,
         setStatus: ctx.setStatus,
+        client,
       }).catch((err) => {
         if (!signal.aborted) {
           ctx.log?.error(`[gmail] Monitor error: ${String(err)}`);
@@ -367,8 +396,9 @@ export const gmailPlugin: ChannelPlugin<ResolvedGmailAccount> = {
       });
 
       // Cleanup after monitor exits
-      if (ctx.account.email) {
-        activeAccounts.delete(ctx.account.email.toLowerCase());
+      if (emailKey) {
+        activeAccounts.delete(emailKey);
+        activeClients.delete(emailKey);
       }
       ctx.setStatus({ accountId: ctx.accountId, running: false, connected: false });
     },

package/src/config.ts

@@ -16,6 +16,12 @@ export const GmailAccountSchema = z.object({
   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)
+  backend: z.enum(["gog", "api"]).optional(), // Gmail backend: gog CLI (default) or googleapis
+  oauth: z.object({
+    clientId: z.string(),
+    clientSecret: z.string(),
+    refreshToken: z.string(),
+  }).optional(), // OAuth2 credentials for API backend
 });
 
 export const GmailConfigSchema = z.object({

package/src/gmail-client.ts

@@ -0,0 +1,50 @@
+import type { ResolvedGmailAccount } from "./accounts.js";
+import type { ThreadResponse } from "./quoting.js";
+import type { GogSearchMessage } from "./inbound.js";
+import { GogGmailClient } from "./gog-client.js";
+import { ApiGmailClient } from "./api-client.js";
+import { resolveOAuthCredentials, createOAuth2Client } from "./auth.js";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+
+export interface GmailClient {
+  send(opts: {
+    account?: string;
+    to?: string;
+    subject: string;
+    textBody: string;
+    htmlBody?: string;
+    threadId?: string;
+    replyToMessageId?: string;
+    replyAll?: boolean;
+  }): Promise<void>;
+
+  getThread(threadId: string, opts?: { full?: boolean }): Promise<ThreadResponse | null>;
+  getMessage(messageId: string): Promise<Record<string, unknown> | null>;
+  searchMessages(query: string, opts?: { maxResults?: number; includeBody?: boolean }): Promise<GogSearchMessage[]>;
+  searchThreads(query: string, opts?: { maxResults?: number }): Promise<Record<string, unknown> | null>;
+  modifyLabels(id: string, opts: { add?: string[]; remove?: string[] }): Promise<void>;
+  modifyThreadLabels(threadId: string, opts: { add?: string[]; remove?: string[] }): Promise<void>;
+  listLabels(): Promise<{ id: string; name: string }[]>;
+  createLabel(name: string): Promise<void>;
+  downloadAttachment(messageId: string, attachmentId: string, outPath: string): Promise<void>;
+  getSendAs(): Promise<{ displayName?: string; email: string; isPrimary?: boolean }[]>;
+}
+
+export function createGmailClient(account: ResolvedGmailAccount, cfg?: OpenClawConfig): GmailClient {
+  if (account.backend === "api") {
+    if (!cfg) {
+      throw new Error(`API backend requires config to resolve OAuth credentials for ${account.email}`);
+    }
+    const creds = resolveOAuthCredentials(account.email, cfg);
+    if (!creds) {
+      throw new Error(
+        `No OAuth credentials found for ${account.email}. ` +
+        `Run onboarding or set oauth.clientId, oauth.clientSecret, and oauth.refreshToken in config.`,
+      );
+    }
+    const auth = createOAuth2Client(creds);
+    return new ApiGmailClient(auth);
+  }
+
+  return new GogGmailClient(account.email);
+}

package/src/gog-client.ts

@@ -0,0 +1,230 @@
+import { spawn } from "node:child_process";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import type { GmailClient } from "./gmail-client.js";
+import type { ThreadResponse } from "./quoting.js";
+import { parseGogThreadOutput } from "./quoting.js";
+import type { GogSearchMessage } from "./inbound.js";
+
+const execFileAsync = promisify(execFile);
+
+const GOG_TIMEOUT_MS = 30_000;
+
+interface CircuitState {
+  consecutiveFailures: number;
+  lastFailureAt: number;
+  backoffUntil: number;
+}
+
+const CIRCUIT_CONFIG = {
+  maxFailures: 3,
+  initialBackoffMs: 60_000,
+  maxBackoffMs: 15 * 60_000,
+};
+
+export class GogGmailClient implements GmailClient {
+  private circuit: CircuitState = { consecutiveFailures: 0, lastFailureAt: 0, backoffUntil: 0 };
+
+  constructor(private accountEmail: string) {}
+
+  /**
+   * Check if the gog CLI is available on PATH.
+   */
+  static async checkExists(): Promise<boolean> {
+    try {
+      await execFileAsync("gog", ["--version"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Write operation via spawn() — fire-and-forget style with retries.
+   * Mirrors outbound.ts:17-44.
+   */
+  private async execGog(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}`));
+          });
+          setTimeout(() => {
+            proc.kill();
+            reject(new Error("gog timed out after 30s"));
+          }, GOG_TIMEOUT_MS);
+        });
+        return;
+      } catch (err) {
+        if (i === retries - 1) throw err;
+        await new Promise((resolve) => setTimeout(resolve, 1000 * (i + 1)));
+      }
+    }
+  }
+
+  /**
+   * Read operation via execFileAsync() with circuit breaker.
+   * Mirrors monitor.ts:70-125.
+   */
+  private async runGog(args: string[], retries = 3): Promise<Record<string, unknown> | null> {
+    const circuit = this.circuit;
+    const now = Date.now();
+
+    if (now < circuit.backoffUntil) {
+      throw new Error(
+        `Circuit breaker active for ${this.accountEmail}. Backing off until ${new Date(circuit.backoffUntil).toISOString()}`,
+      );
+    }
+
+    const allArgs = ["--json", "--account", this.accountEmail, ...args];
+    let lastErr: any;
+
+    for (let i = 0; i < retries; i++) {
+      try {
+        const { stdout } = await execFileAsync("gog", allArgs, {
+          maxBuffer: 10 * 1024 * 1024,
+          timeout: GOG_TIMEOUT_MS,
+        });
+
+        // Success — reset circuit
+        circuit.consecutiveFailures = 0;
+        circuit.backoffUntil = 0;
+
+        if (!stdout.trim()) return null;
+        return JSON.parse(stdout) as Record<string, unknown>;
+      } catch (err: unknown) {
+        lastErr = err;
+        const msg = String(err);
+
+        // 404 → not found, not a failure
+        if (msg.includes("404")) return null;
+
+        // Trip circuit breaker on auth / server errors
+        if (msg.includes("403") || msg.includes("invalid_grant") || msg.includes("ETIMEDOUT") || msg.includes("500")) {
+          circuit.consecutiveFailures++;
+          circuit.lastFailureAt = Date.now();
+
+          if (circuit.consecutiveFailures >= CIRCUIT_CONFIG.maxFailures) {
+            const backoff = Math.min(
+              CIRCUIT_CONFIG.initialBackoffMs * Math.pow(2, circuit.consecutiveFailures - CIRCUIT_CONFIG.maxFailures),
+              CIRCUIT_CONFIG.maxBackoffMs,
+            );
+            circuit.backoffUntil = Date.now() + backoff;
+          }
+          break;
+        }
+
+        if (i < retries - 1) {
+          await new Promise((resolve) => setTimeout(resolve, 1000 * (i + 1)));
+        }
+      }
+    }
+
+    const error = lastErr as { stderr?: string; message?: string };
+    throw new Error(`gog failed: ${error.stderr || error.message || String(lastErr)}`);
+  }
+
+  // ── GmailClient interface ──────────────────────────────────────────
+
+  async send(opts: {
+    account?: string;
+    to?: string;
+    subject: string;
+    textBody: string;
+    htmlBody?: string;
+    threadId?: string;
+    replyToMessageId?: string;
+    replyAll?: boolean;
+  }): Promise<void> {
+    const args = ["gmail", "send"];
+    if (this.accountEmail) args.push("--account", this.accountEmail);
+    if (opts.to) args.push("--to", opts.to);
+    if (opts.subject) args.push("--subject", opts.subject);
+    if (opts.threadId) args.push("--thread-id", opts.threadId);
+    if (opts.replyToMessageId) args.push("--reply-to-message-id", opts.replyToMessageId);
+    if (opts.replyAll) args.push("--reply-all");
+    if (opts.htmlBody) args.push("--body-html", opts.htmlBody);
+    args.push("--body", opts.textBody);
+    await this.execGog(args);
+  }
+
+  async getThread(threadId: string, opts?: { full?: boolean }): Promise<ThreadResponse | null> {
+    const args = ["gmail", "thread", "get", threadId];
+    if (opts?.full !== false) args.push("--full");
+    const data = await this.runGog(args);
+    if (!data) return null;
+    return parseGogThreadOutput(data);
+  }
+
+  async getMessage(messageId: string): Promise<Record<string, unknown> | null> {
+    return this.runGog(["gmail", "get", messageId]);
+  }
+
+  async searchMessages(
+    query: string,
+    opts?: { maxResults?: number; includeBody?: boolean },
+  ): Promise<GogSearchMessage[]> {
+    const args = ["gmail", "messages", "search", query];
+    if (opts?.includeBody !== false) args.push("--include-body");
+    args.push("--max", String(opts?.maxResults ?? 50));
+    const res = await this.runGog(args);
+    if (!res || !Array.isArray((res as any).messages)) return [];
+    return (res as any).messages as GogSearchMessage[];
+  }
+
+  async searchThreads(query: string, opts?: { maxResults?: number }): Promise<Record<string, unknown> | null> {
+    const args = ["gmail", "search", query];
+    args.push("--max", String(opts?.maxResults ?? 50));
+    return this.runGog(args);
+  }
+
+  async modifyLabels(id: string, opts: { add?: string[]; remove?: string[] }): Promise<void> {
+    const args = ["gmail", "labels", "modify", id];
+    if (opts.add) for (const l of opts.add) args.push("--add", l);
+    if (opts.remove) for (const l of opts.remove) args.push("--remove", l);
+    await this.runGog(args);
+  }
+
+  async modifyThreadLabels(threadId: string, opts: { add?: string[]; remove?: string[] }): Promise<void> {
+    const args = ["gmail", "thread", "modify", threadId];
+    if (opts.add) for (const l of opts.add) args.push("--add", l);
+    if (opts.remove) for (const l of opts.remove) args.push("--remove", l);
+    await this.runGog(args);
+  }
+
+  async listLabels(): Promise<{ id: string; name: string }[]> {
+    const res = await this.runGog(["gmail", "labels", "list"]);
+    return ((res as any)?.labels || []) as { id: string; name: string }[];
+  }
+
+  async createLabel(name: string): Promise<void> {
+    await this.runGog(["gmail", "labels", "create", name]);
+  }
+
+  async downloadAttachment(messageId: string, attachmentId: string, outPath: string): Promise<void> {
+    // No circuit breaker for attachment downloads
+    await execFileAsync("gog", [
+      "gmail",
+      "attachment",
+      messageId,
+      attachmentId,
+      "--account",
+      this.accountEmail,
+      "--out",
+      outPath,
+    ]);
+  }
+
+  async getSendAs(): Promise<{ displayName?: string; email: string; isPrimary?: boolean }[]> {
+    const res = await this.runGog(["gmail", "settings", "sendas", "list"]);
+    return ((res as any)?.sendAs || []) as { displayName?: string; email: string; isPrimary?: boolean }[];
+  }
+}

package/src/mime.ts

@@ -0,0 +1,37 @@
+import MailComposer from "nodemailer/lib/mail-composer";
+
+export interface MimeMessageOpts {
+  from: string;
+  to: string;
+  cc?: string;
+  subject: string;
+  text: string;
+  html?: string;
+  inReplyTo?: string;
+  references?: string;
+}
+
+/**
+ * Build an RFC 2822 MIME message using nodemailer's MailComposer.
+ * Returns a Buffer suitable for base64url encoding and passing to
+ * gmail.users.messages.send.
+ */
+export function buildMimeMessage(opts: MimeMessageOpts): Promise<Buffer> {
+  const mail = new MailComposer({
+    from: opts.from,
+    to: opts.to,
+    cc: opts.cc,
+    subject: opts.subject,
+    text: opts.text,
+    html: opts.html,
+    inReplyTo: opts.inReplyTo,
+    references: opts.references,
+  });
+
+  return new Promise((resolve, reject) => {
+    mail.compile().build((err: Error | null, message: Buffer) => {
+      if (err) reject(err);
+      else resolve(message);
+    });
+  });
+}