@digitalpresence/cliclaw 0.1.0

package/src/gmail/drafts.ts

@@ -0,0 +1,166 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputAuthRequired } from "../lib/output.js";
+
+function encodeDraftMessage(headers: Record<string, string>, body: string): string {
+  const headerLines = Object.entries(headers)
+    .filter(([, v]) => v)
+    .map(([k, v]) => `${k}: ${v}`)
+    .join("\r\n");
+  const raw = `${headerLines}\r\n\r\n${body}`;
+  return Buffer.from(raw).toString("base64url");
+}
+
+export async function handleDraftList(
+  clientManager: OAuthClientManager,
+  account: string,
+  maxResults: number,
+): Promise<void> {
+  if (!clientManager.listAccounts().includes(account)) {
+    outputAuthRequired();
+  }
+
+  const client = clientManager.getClient(account);
+  const gmail = google.gmail({ version: "v1", auth: client });
+
+  const listRes = await gmail.users.drafts.list({ userId: "me", maxResults });
+  const drafts = listRes.data.drafts ?? [];
+
+  if (drafts.length === 0) {
+    outputJson([]);
+    return;
+  }
+
+  const summaries = await Promise.all(
+    drafts.map(async (draft) => {
+      const detail = await gmail.users.drafts.get({
+        userId: "me",
+        id: draft.id!,
+        format: "metadata",
+      });
+      const headers = detail.data.message?.payload?.headers ?? [];
+      const get = (name: string) =>
+        headers.find((h) => h.name?.toLowerCase() === name.toLowerCase())?.value ?? "";
+      return {
+        id: draft.id ?? "",
+        messageId: detail.data.message?.id ?? "",
+        subject: get("Subject"),
+        to: get("To"),
+        snippet: detail.data.message?.snippet ?? "",
+      };
+    }),
+  );
+
+  outputJson(summaries);
+}
+
+export async function handleDraftCreate(
+  clientManager: OAuthClientManager,
+  account: string,
+  to: string,
+  subject: string,
+  body: string,
+  cc?: string,
+  bcc?: string,
+): Promise<void> {
+  if (!clientManager.listAccounts().includes(account)) {
+    outputAuthRequired();
+  }
+
+  const client = clientManager.getClient(account);
+  const gmail = google.gmail({ version: "v1", auth: client });
+
+  const raw = encodeDraftMessage(
+    {
+      To: to,
+      Subject: subject,
+      Cc: cc ?? "",
+      Bcc: bcc ?? "",
+      "Content-Type": "text/plain; charset=utf-8",
+      "MIME-Version": "1.0",
+    },
+    body,
+  );
+
+  const res = await gmail.users.drafts.create({
+    userId: "me",
+    requestBody: { message: { raw } },
+  });
+
+  outputJson({ id: res.data.id, messageId: res.data.message?.id, success: true });
+}
+
+export async function handleDraftUpdate(
+  clientManager: OAuthClientManager,
+  account: string,
+  draftId: string,
+  to: string,
+  subject: string,
+  body: string,
+  cc?: string,
+  bcc?: string,
+): Promise<void> {
+  if (!clientManager.listAccounts().includes(account)) {
+    outputAuthRequired();
+  }
+
+  const client = clientManager.getClient(account);
+  const gmail = google.gmail({ version: "v1", auth: client });
+
+  const raw = encodeDraftMessage(
+    {
+      To: to,
+      Subject: subject,
+      Cc: cc ?? "",
+      Bcc: bcc ?? "",
+      "Content-Type": "text/plain; charset=utf-8",
+      "MIME-Version": "1.0",
+    },
+    body,
+  );
+
+  const res = await gmail.users.drafts.update({
+    userId: "me",
+    id: draftId,
+    requestBody: { message: { raw } },
+  });
+
+  outputJson({ id: res.data.id, messageId: res.data.message?.id, success: true });
+}
+
+export async function handleDraftDelete(
+  clientManager: OAuthClientManager,
+  account: string,
+  draftId: string,
+): Promise<void> {
+  if (!clientManager.listAccounts().includes(account)) {
+    outputAuthRequired();
+  }
+
+  const client = clientManager.getClient(account);
+  const gmail = google.gmail({ version: "v1", auth: client });
+
+  await gmail.users.drafts.delete({ userId: "me", id: draftId });
+
+  outputJson({ draft_id: draftId, success: true });
+}
+
+export async function handleDraftSend(
+  clientManager: OAuthClientManager,
+  account: string,
+  draftId: string,
+): Promise<void> {
+  if (!clientManager.listAccounts().includes(account)) {
+    outputAuthRequired();
+  }
+
+  const client = clientManager.getClient(account);
+  const gmail = google.gmail({ version: "v1", auth: client });
+
+  const res = await gmail.users.drafts.send({
+    userId: "me",
+    requestBody: { id: draftId },
+  });
+
+  outputJson({ id: res.data.id, threadId: res.data.threadId, success: true });
+}

package/src/gmail/get.ts

@@ -0,0 +1,195 @@
+import { writeFileSync } from "fs";
+import * as path from "path";
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { ensureDir, sanitizeFilename, extToMime } from "../lib/media-utils.js";
+import { outputJson, outputAuthRequired, outputError } from "../lib/output.js";
+
+interface MessagePart {
+  partId?: string | null;
+  mimeType?: string | null;
+  filename?: string | null;
+  headers?: Array<{ name?: string | null; value?: string | null }> | null;
+  body?: { data?: string | null; attachmentId?: string | null; size?: number | null } | null;
+  parts?: MessagePart[] | null;
+}
+
+interface AttachmentMeta {
+  filename: string;
+  mimeType: string;
+  size: number;
+  attachmentId: string;
+  partId: string;
+}
+
+function extractBody(parts: MessagePart[] | null | undefined): { text: string; html: string } {
+  let text = "";
+  let html = "";
+
+  function traverse(part: MessagePart) {
+    if (part.mimeType === "text/plain" && part.body?.data) {
+      text += Buffer.from(part.body.data, "base64").toString("utf-8");
+    } else if (part.mimeType === "text/html" && part.body?.data) {
+      html += Buffer.from(part.body.data, "base64").toString("utf-8");
+    }
+    if (part.parts) {
+      for (const child of part.parts) {
+        traverse(child);
+      }
+    }
+  }
+
+  if (parts) {
+    for (const part of parts) {
+      traverse(part);
+    }
+  }
+
+  return { text, html };
+}
+
+function extractAttachments(parts: MessagePart[] | null | undefined): AttachmentMeta[] {
+  const results: AttachmentMeta[] = [];
+
+  function traverse(part: MessagePart) {
+    const attachmentId = part.body?.attachmentId ?? null;
+    const filenameHeader = part.headers?.find(
+      (h) => h.name?.toLowerCase() === "content-disposition",
+    )?.value;
+
+    let filename = part.filename ?? null;
+    if (!filename && filenameHeader) {
+      const match = filenameHeader.match(/filename\*?=(?:UTF-8'')?["']?([^"';\r\n]+)["']?/i);
+      if (match) {
+        filename = decodeURIComponent(match[1].trim());
+      }
+    }
+
+    if (attachmentId && filename) {
+      results.push({
+        filename,
+        mimeType: part.mimeType ?? "application/octet-stream",
+        size: part.body?.size ?? 0,
+        attachmentId,
+        partId: part.partId ?? "",
+      });
+    }
+
+    if (part.parts) {
+      for (const child of part.parts) {
+        traverse(child);
+      }
+    }
+  }
+
+  if (parts) {
+    for (const part of parts) {
+      traverse(part);
+    }
+  }
+
+  return results;
+}
+
+export async function handleGet(
+  clientManager: OAuthClientManager,
+  account: string,
+  id: string,
+): Promise<void> {
+  if (!clientManager.listAccounts().includes(account)) {
+    outputAuthRequired();
+  }
+
+  const client = clientManager.getClient(account);
+  const gmail = google.gmail({ version: "v1", auth: client });
+
+  const res = await gmail.users.messages.get({
+    userId: "me",
+    id,
+    format: "full",
+  });
+
+  const payload = res.data.payload;
+  const headers = payload?.headers ?? [];
+  const get = (name: string) =>
+    headers.find((h) => h.name?.toLowerCase() === name.toLowerCase())?.value ?? "";
+
+  let bodyText = "";
+  let bodyHtml = "";
+
+  if (payload?.body?.data) {
+    const decoded = Buffer.from(payload.body.data, "base64").toString("utf-8");
+    if (payload.mimeType === "text/html") {
+      bodyHtml = decoded;
+    } else {
+      bodyText = decoded;
+    }
+  } else {
+    const { text, html } = extractBody(payload?.parts as MessagePart[] | undefined);
+    bodyText = text;
+    bodyHtml = html;
+  }
+
+  const attachments = extractAttachments(payload?.parts as MessagePart[] | undefined);
+
+  outputJson({
+    id: res.data.id ?? id,
+    threadId: res.data.threadId ?? "",
+    subject: get("Subject"),
+    from: get("From"),
+    to: get("To"),
+    cc: get("Cc"),
+    bcc: get("Bcc"),
+    reply_to: get("Reply-To"),
+    date: get("Date"),
+    snippet: res.data.snippet ?? "",
+    labelIds: res.data.labelIds ?? [],
+    body_text: bodyText,
+    body_html: bodyHtml,
+    attachments,
+  });
+}
+
+export async function handleDownloadAttachment(
+  clientManager: OAuthClientManager,
+  account: string,
+  id: string,
+  attachmentId: string,
+  filename: string,
+  saveDir: string,
+): Promise<void> {
+  if (!clientManager.listAccounts().includes(account)) {
+    outputAuthRequired();
+  }
+
+  const client = clientManager.getClient(account);
+  const gmail = google.gmail({ version: "v1", auth: client });
+
+  const res = await gmail.users.messages.attachments.get({
+    userId: "me",
+    messageId: id,
+    id: attachmentId,
+  });
+
+  const data = res.data.data;
+  if (!data) {
+    outputError("no_data", "Attachment returned no data.");
+  }
+
+  const buffer = Buffer.from(data!, "base64url");
+
+  ensureDir(saveDir);
+  const safeFilename = sanitizeFilename(filename);
+  const filePath = path.join(saveDir, safeFilename);
+  writeFileSync(filePath, buffer);
+
+  const ext = path.extname(safeFilename);
+  const mimeType = extToMime(ext) || "application/octet-stream";
+
+  outputJson({
+    path: filePath,
+    filename: safeFilename,
+    mimeType,
+    size: buffer.length,
+  });
+}

package/src/gmail/inbox.ts

@@ -0,0 +1,78 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputAuthRequired } from "../lib/output.js";
+
+interface MessageSummary {
+  id: string;
+  subject: string;
+  from: string;
+  date: string;
+  snippet: string;
+}
+
+async function fetchMessages(
+  clientManager: OAuthClientManager,
+  account: string,
+  maxResults: number,
+  query?: string,
+  labelIds?: string[],
+): Promise<MessageSummary[]> {
+  if (!clientManager.listAccounts().includes(account)) {
+    outputAuthRequired();
+  }
+
+  const client = clientManager.getClient(account);
+  const gmail = google.gmail({ version: "v1", auth: client });
+
+  const listRes = await gmail.users.messages.list({
+    userId: "me",
+    ...(labelIds ? { labelIds } : {}),
+    maxResults,
+    ...(query ? { q: query } : {}),
+  });
+
+  const messages = listRes.data.messages ?? [];
+  if (messages.length === 0) return [];
+
+  const summaries = await Promise.all(
+    messages.map(async (msg) => {
+      const detail = await gmail.users.messages.get({
+        userId: "me",
+        id: msg.id!,
+        format: "metadata",
+        metadataHeaders: ["Subject", "From", "Date"],
+      });
+      const headers = detail.data.payload?.headers ?? [];
+      const get = (name: string) =>
+        headers.find((h) => h.name?.toLowerCase() === name.toLowerCase())?.value ?? "";
+      return {
+        id: msg.id ?? "",
+        subject: get("Subject"),
+        from: get("From"),
+        date: get("Date"),
+        snippet: detail.data.snippet ?? "",
+      };
+    }),
+  );
+
+  return summaries;
+}
+
+export async function handleInbox(
+  clientManager: OAuthClientManager,
+  account: string,
+  maxResults: number,
+): Promise<void> {
+  const result = await fetchMessages(clientManager, account, maxResults, undefined, ["INBOX"]);
+  outputJson(result);
+}
+
+export async function handleSearch(
+  clientManager: OAuthClientManager,
+  account: string,
+  query: string,
+  maxResults: number,
+): Promise<void> {
+  const result = await fetchMessages(clientManager, account, maxResults, query);
+  outputJson(result);
+}

package/src/gmail/labels.ts

@@ -0,0 +1,69 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputAuthRequired } from "../lib/output.js";
+
+export async function handleLabelsList(
+  clientManager: OAuthClientManager,
+  account: string,
+): Promise<void> {
+  if (!clientManager.listAccounts().includes(account)) {
+    outputAuthRequired();
+  }
+
+  const client = clientManager.getClient(account);
+  const gmail = google.gmail({ version: "v1", auth: client });
+
+  const res = await gmail.users.labels.list({ userId: "me" });
+  const labels = res.data.labels ?? [];
+
+  const result = labels.map((label) => ({
+    id: label.id ?? "",
+    name: label.name ?? "",
+    type: label.type ?? "",
+    messagesTotal: label.messagesTotal ?? 0,
+    messagesUnread: label.messagesUnread ?? 0,
+  }));
+
+  outputJson(result);
+}
+
+export async function handleLabelCreate(
+  clientManager: OAuthClientManager,
+  account: string,
+  name: string,
+): Promise<void> {
+  if (!clientManager.listAccounts().includes(account)) {
+    outputAuthRequired();
+  }
+
+  const client = clientManager.getClient(account);
+  const gmail = google.gmail({ version: "v1", auth: client });
+
+  const res = await gmail.users.labels.create({
+    userId: "me",
+    requestBody: {
+      name,
+      labelListVisibility: "labelShow",
+      messageListVisibility: "show",
+    },
+  });
+
+  outputJson({ id: res.data.id, name: res.data.name, success: true });
+}
+
+export async function handleLabelDelete(
+  clientManager: OAuthClientManager,
+  account: string,
+  labelId: string,
+): Promise<void> {
+  if (!clientManager.listAccounts().includes(account)) {
+    outputAuthRequired();
+  }
+
+  const client = clientManager.getClient(account);
+  const gmail = google.gmail({ version: "v1", auth: client });
+
+  await gmail.users.labels.delete({ userId: "me", id: labelId });
+
+  outputJson({ label_id: labelId, success: true });
+}

package/src/gmail/modify.ts

@@ -0,0 +1,89 @@
+import { google } from "googleapis";
+import type { OAuthClientManager } from "@digitalpresence/cliclaw-auth";
+import { outputJson, outputAuthRequired } from "../lib/output.js";
+
+type ModifyAction =
+  | "mark_read"
+  | "mark_unread"
+  | "archive"
+  | "trash"
+  | "untrash"
+  | "star"
+  | "unstar"
+  | "add_labels"
+  | "remove_labels";
+
+export async function handleModify(
+  clientManager: OAuthClientManager,
+  account: string,
+  id: string,
+  action: ModifyAction,
+  labelIds?: string[],
+): Promise<void> {
+  if (!clientManager.listAccounts().includes(account)) {
+    outputAuthRequired();
+  }
+
+  const client = clientManager.getClient(account);
+  const gmail = google.gmail({ version: "v1", auth: client });
+
+  switch (action) {
+    case "mark_read":
+      await gmail.users.messages.modify({
+        userId: "me",
+        id,
+        requestBody: { removeLabelIds: ["UNREAD"] },
+      });
+      break;
+    case "mark_unread":
+      await gmail.users.messages.modify({
+        userId: "me",
+        id,
+        requestBody: { addLabelIds: ["UNREAD"] },
+      });
+      break;
+    case "archive":
+      await gmail.users.messages.modify({
+        userId: "me",
+        id,
+        requestBody: { removeLabelIds: ["INBOX"] },
+      });
+      break;
+    case "trash":
+      await gmail.users.messages.trash({ userId: "me", id });
+      break;
+    case "untrash":
+      await gmail.users.messages.untrash({ userId: "me", id });
+      break;
+    case "star":
+      await gmail.users.messages.modify({
+        userId: "me",
+        id,
+        requestBody: { addLabelIds: ["STARRED"] },
+      });
+      break;
+    case "unstar":
+      await gmail.users.messages.modify({
+        userId: "me",
+        id,
+        requestBody: { removeLabelIds: ["STARRED"] },
+      });
+      break;
+    case "add_labels":
+      await gmail.users.messages.modify({
+        userId: "me",
+        id,
+        requestBody: { addLabelIds: labelIds ?? [] },
+      });
+      break;
+    case "remove_labels":
+      await gmail.users.messages.modify({
+        userId: "me",
+        id,
+        requestBody: { removeLabelIds: labelIds ?? [] },
+      });
+      break;
+  }
+
+  outputJson({ id, action, success: true });
+}