@cli4ai/gmail 1.0.1 → 1.0.2

package/lib/labels.ts

@@ -0,0 +1,198 @@
+import { getGmail, output, type OutputOptions } from './api';
+
+/** Label data */
+export interface LabelData {
+  id: string;
+  name: string;
+  type?: string;
+  messageListVisibility?: string;
+  labelListVisibility?: string;
+  messagesTotal?: number;
+  messagesUnread?: number;
+  threadsTotal?: number;
+  threadsUnread?: number;
+}
+
+/** Label action result */
+export interface LabelActionResult {
+  ok: boolean;
+  id?: string;
+  name?: string;
+  messageId?: string;
+  labelAdded?: string;
+  labelRemoved?: string;
+  deleted?: string;
+}
+
+/**
+ * List all labels
+ */
+export async function list(options: OutputOptions = {}): Promise<LabelData[]> {
+  const gmail = await getGmail();
+
+  const res = await gmail.users.labels.list({
+    userId: 'me'
+  });
+
+  const labels: LabelData[] = (res.data.labels || []).map(label => ({
+    id: label.id!,
+    name: label.name!,
+    type: label.type || undefined,
+    messageListVisibility: label.messageListVisibility || undefined,
+    labelListVisibility: label.labelListVisibility || undefined
+  }));
+
+  // Sort: system labels first, then user labels
+  labels.sort((a, b) => {
+    if (a.type === 'system' && b.type !== 'system') return -1;
+    if (a.type !== 'system' && b.type === 'system') return 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  output(labels, options);
+  return labels;
+}
+
+/**
+ * Get label details with counts
+ */
+export async function get(labelId: string, options: OutputOptions = {}): Promise<LabelData> {
+  const gmail = await getGmail();
+
+  // Resolve label name to ID if needed
+  const resolvedId = await resolveLabelId(gmail, labelId);
+
+  const res = await gmail.users.labels.get({
+    userId: 'me',
+    id: resolvedId
+  });
+
+  const label: LabelData = {
+    id: res.data.id!,
+    name: res.data.name!,
+    type: res.data.type || undefined,
+    messagesTotal: res.data.messagesTotal || undefined,
+    messagesUnread: res.data.messagesUnread || undefined,
+    threadsTotal: res.data.threadsTotal || undefined,
+    threadsUnread: res.data.threadsUnread || undefined
+  };
+
+  output(label, options);
+  return label;
+}
+
+/**
+ * Add label to message
+ */
+export async function addToMessage(messageId: string, labelName: string, options: OutputOptions = {}): Promise<LabelActionResult> {
+  const gmail = await getGmail();
+
+  const labelId = await resolveLabelId(gmail, labelName);
+
+  await gmail.users.messages.modify({
+    userId: 'me',
+    id: messageId,
+    requestBody: {
+      addLabelIds: [labelId]
+    }
+  });
+
+  const result: LabelActionResult = { ok: true, messageId, labelAdded: labelName };
+  output(result, options);
+  return result;
+}
+
+/**
+ * Remove label from message
+ */
+export async function removeFromMessage(messageId: string, labelName: string, options: OutputOptions = {}): Promise<LabelActionResult> {
+  const gmail = await getGmail();
+
+  const labelId = await resolveLabelId(gmail, labelName);
+
+  await gmail.users.messages.modify({
+    userId: 'me',
+    id: messageId,
+    requestBody: {
+      removeLabelIds: [labelId]
+    }
+  });
+
+  const result: LabelActionResult = { ok: true, messageId, labelRemoved: labelName };
+  output(result, options);
+  return result;
+}
+
+/**
+ * Create a new label
+ */
+export async function create(labelName: string, options: OutputOptions = {}): Promise<LabelActionResult> {
+  const gmail = await getGmail();
+
+  const res = await gmail.users.labels.create({
+    userId: 'me',
+    requestBody: {
+      name: labelName,
+      labelListVisibility: 'labelShow',
+      messageListVisibility: 'show'
+    }
+  });
+
+  const result: LabelActionResult = {
+    ok: true,
+    id: res.data.id!,
+    name: res.data.name!
+  };
+
+  output(result, options);
+  return result;
+}
+
+/**
+ * Delete a label
+ */
+export async function remove(labelName: string, options: OutputOptions = {}): Promise<LabelActionResult> {
+  const gmail = await getGmail();
+
+  const labelId = await resolveLabelId(gmail, labelName);
+
+  // Don't allow deleting system labels
+  const systemLabels = ['INBOX', 'SENT', 'TRASH', 'SPAM', 'STARRED', 'UNREAD', 'IMPORTANT', 'DRAFT'];
+  if (labelId.startsWith('CATEGORY_') || systemLabels.includes(labelId)) {
+    throw new Error(`Cannot delete system label: ${labelName}`);
+  }
+
+  await gmail.users.labels.delete({
+    userId: 'me',
+    id: labelId
+  });
+
+  const result: LabelActionResult = { ok: true, deleted: labelName };
+  output(result, options);
+  return result;
+}
+
+/**
+ * Resolve label name to ID
+ */
+async function resolveLabelId(gmail: ReturnType<typeof import('googleapis').google.gmail>, labelNameOrId: string): Promise<string> {
+  // Check if already an ID (system labels or Label_xxx format)
+  const systemLabels = ['INBOX', 'SENT', 'TRASH', 'SPAM', 'STARRED', 'UNREAD', 'IMPORTANT', 'DRAFT', 'CHAT'];
+  if (labelNameOrId.startsWith('Label_') ||
+      labelNameOrId.startsWith('CATEGORY_') ||
+      systemLabels.includes(labelNameOrId.toUpperCase())) {
+    return labelNameOrId.toUpperCase();
+  }
+
+  // Look up by name
+  const res = await gmail.users.labels.list({ userId: 'me' });
+  const label = res.data.labels?.find(
+    l => l.name?.toLowerCase() === labelNameOrId.toLowerCase()
+  );
+
+  if (!label) {
+    throw new Error(`Label not found: ${labelNameOrId}`);
+  }
+
+  return label.id!;
+}

package/lib/messages.ts

@@ -0,0 +1,310 @@
+import { getGmail, output, formatDate, extractHeaders, extractBody, cleanBody, type OutputOptions, type MessagePayload } from './api';
+
+/** Message summary */
+export interface MessageSummary {
+  id: string;
+  threadId?: string;
+  date: string | null;
+  from: string;
+  to: string;
+  subject: string;
+  snippet?: string;
+  labels?: string[];
+  unread?: boolean;
+  starred?: boolean;
+  important?: boolean;
+  body?: string;
+  cc?: string | null;
+}
+
+/** Action result */
+export interface ActionResult {
+  ok: boolean;
+  archived?: string;
+  trashed?: string;
+  untrashed?: string;
+  starred?: string;
+  unstarred?: string;
+  markedRead?: string;
+  markedUnread?: string;
+}
+
+/** Message list options */
+export interface MessageListOptions extends OutputOptions {
+  limit?: number;
+  body?: boolean;
+}
+
+/**
+ * List inbox messages
+ */
+export async function inbox(options: MessageListOptions = {}): Promise<MessageSummary[]> {
+  const gmail = await getGmail();
+  const limit = options.limit || 20;
+
+  const res = await gmail.users.messages.list({
+    userId: 'me',
+    maxResults: limit,
+    labelIds: ['INBOX']
+  });
+
+  if (!res.data.messages || res.data.messages.length === 0) {
+    output([], options);
+    return [];
+  }
+
+  const messages = await Promise.all(
+    res.data.messages.map(msg => getMessageSummary(gmail, msg.id!, options))
+  );
+
+  output(messages, options);
+  return messages;
+}
+
+/**
+ * List unread messages
+ */
+export async function unread(options: MessageListOptions = {}): Promise<MessageSummary[]> {
+  const gmail = await getGmail();
+  const limit = options.limit || 20;
+
+  const res = await gmail.users.messages.list({
+    userId: 'me',
+    maxResults: limit,
+    q: 'is:unread'
+  });
+
+  if (!res.data.messages || res.data.messages.length === 0) {
+    output([], options);
+    return [];
+  }
+
+  const messages = await Promise.all(
+    res.data.messages.map(msg => getMessageSummary(gmail, msg.id!, options))
+  );
+
+  output(messages, options);
+  return messages;
+}
+
+/**
+ * Search messages with Gmail query syntax
+ */
+export async function search(query: string, options: MessageListOptions = {}): Promise<MessageSummary[]> {
+  const gmail = await getGmail();
+  const limit = options.limit || 20;
+
+  const res = await gmail.users.messages.list({
+    userId: 'me',
+    maxResults: limit,
+    q: query
+  });
+
+  if (!res.data.messages || res.data.messages.length === 0) {
+    output([], options);
+    return [];
+  }
+
+  const messages = await Promise.all(
+    res.data.messages.map(msg => getMessageSummary(gmail, msg.id!, options))
+  );
+
+  output(messages, options);
+  return messages;
+}
+
+/**
+ * Get message summary (for list views)
+ */
+async function getMessageSummary(gmail: ReturnType<typeof import('googleapis').google.gmail>, messageId: string, options: MessageListOptions = {}): Promise<MessageSummary> {
+  const res = await gmail.users.messages.get({
+    userId: 'me',
+    id: messageId,
+    format: options.body ? 'full' : 'metadata',
+    metadataHeaders: ['From', 'To', 'Subject', 'Date']
+  });
+
+  const headers = extractHeaders(res.data.payload?.headers as Array<{ name: string; value: string }>);
+  const labels = res.data.labelIds || [];
+
+  const summary: MessageSummary = {
+    id: res.data.id!,
+    threadId: res.data.threadId || undefined,
+    date: formatDate(res.data.internalDate),
+    from: headers.from || '',
+    to: headers.to || '',
+    subject: headers.subject || '(no subject)',
+    snippet: res.data.snippet || '',
+    labels: labels,
+    unread: labels.includes('UNREAD'),
+    starred: labels.includes('STARRED'),
+    important: labels.includes('IMPORTANT')
+  };
+
+  if (options.body) {
+    summary.body = cleanBody(extractBody(res.data.payload as MessagePayload), 1000);
+  }
+
+  return summary;
+}
+
+/**
+ * Read a full message
+ */
+export async function read(messageId: string, options: OutputOptions = {}): Promise<MessageSummary> {
+  const gmail = await getGmail();
+
+  const res = await gmail.users.messages.get({
+    userId: 'me',
+    id: messageId,
+    format: 'full'
+  });
+
+  const headers = extractHeaders(res.data.payload?.headers as Array<{ name: string; value: string }>);
+  const labels = res.data.labelIds || [];
+  const body = extractBody(res.data.payload as MessagePayload);
+
+  const message: MessageSummary = {
+    id: res.data.id!,
+    threadId: res.data.threadId || undefined,
+    date: formatDate(res.data.internalDate),
+    from: headers.from || '',
+    to: headers.to || '',
+    cc: headers.cc || null,
+    subject: headers.subject || '(no subject)',
+    body: body,
+    labels: labels,
+    unread: labels.includes('UNREAD'),
+    starred: labels.includes('STARRED')
+  };
+
+  output(message, options);
+  return message;
+}
+
+/**
+ * Archive a message (remove from INBOX)
+ */
+export async function archive(messageId: string, options: OutputOptions = {}): Promise<ActionResult> {
+  const gmail = await getGmail();
+
+  await gmail.users.messages.modify({
+    userId: 'me',
+    id: messageId,
+    requestBody: {
+      removeLabelIds: ['INBOX']
+    }
+  });
+
+  const result: ActionResult = { ok: true, archived: messageId };
+  output(result, options);
+  return result;
+}
+
+/**
+ * Trash a message
+ */
+export async function trash(messageId: string, options: OutputOptions = {}): Promise<ActionResult> {
+  const gmail = await getGmail();
+
+  await gmail.users.messages.trash({
+    userId: 'me',
+    id: messageId
+  });
+
+  const result: ActionResult = { ok: true, trashed: messageId };
+  output(result, options);
+  return result;
+}
+
+/**
+ * Untrash a message
+ */
+export async function untrash(messageId: string, options: OutputOptions = {}): Promise<ActionResult> {
+  const gmail = await getGmail();
+
+  await gmail.users.messages.untrash({
+    userId: 'me',
+    id: messageId
+  });
+
+  const result: ActionResult = { ok: true, untrashed: messageId };
+  output(result, options);
+  return result;
+}
+
+/**
+ * Star a message
+ */
+export async function star(messageId: string, options: OutputOptions = {}): Promise<ActionResult> {
+  const gmail = await getGmail();
+
+  await gmail.users.messages.modify({
+    userId: 'me',
+    id: messageId,
+    requestBody: {
+      addLabelIds: ['STARRED']
+    }
+  });
+
+  const result: ActionResult = { ok: true, starred: messageId };
+  output(result, options);
+  return result;
+}
+
+/**
+ * Unstar a message
+ */
+export async function unstar(messageId: string, options: OutputOptions = {}): Promise<ActionResult> {
+  const gmail = await getGmail();
+
+  await gmail.users.messages.modify({
+    userId: 'me',
+    id: messageId,
+    requestBody: {
+      removeLabelIds: ['STARRED']
+    }
+  });
+
+  const result: ActionResult = { ok: true, unstarred: messageId };
+  output(result, options);
+  return result;
+}
+
+/**
+ * Mark as read
+ */
+export async function markRead(messageId: string, options: OutputOptions = {}): Promise<ActionResult> {
+  const gmail = await getGmail();
+
+  await gmail.users.messages.modify({
+    userId: 'me',
+    id: messageId,
+    requestBody: {
+      removeLabelIds: ['UNREAD']
+    }
+  });
+
+  const result: ActionResult = { ok: true, markedRead: messageId };
+  output(result, options);
+  return result;
+}
+
+/**
+ * Mark as unread
+ */
+export async function markUnread(messageId: string, options: OutputOptions = {}): Promise<ActionResult> {
+  const gmail = await getGmail();
+
+  await gmail.users.messages.modify({
+    userId: 'me',
+    id: messageId,
+    requestBody: {
+      addLabelIds: ['UNREAD']
+    }
+  });
+
+  const result: ActionResult = { ok: true, markedUnread: messageId };
+  output(result, options);
+  return result;
+}