@plosson/agentio 0.1.13 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plosson/agentio",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "CLI for LLM agents to interact with communication and tracking services",
   "type": "module",
   "license": "MIT",

package/src/commands/gmail.ts

@@ -1,12 +1,12 @@
 import { Command } from 'commander';
-import { basename } from 'path';
+import { basename, join } from 'path';
 import { google } from 'googleapis';
 import { getValidTokens, createGoogleAuth } from '../auth/token-manager';
 import { setCredentials, removeCredentials, getCredentials } from '../auth/token-store';
 import { setProfile, removeProfile, listProfiles } from '../config/config-manager';
 import { performOAuthFlow } from '../auth/oauth';
 import { GmailClient } from '../services/gmail/client';
-import { printMessageList, printMessage, printSendResult, printArchived, printMarked, raw } from '../utils/output';
+import { printMessageList, printMessage, printSendResult, printArchived, printMarked, printAttachmentList, printAttachmentDownloaded, raw } from '../utils/output';
 import { CliError, handleError } from '../utils/errors';
 import { readStdin, resolveProfileName } from '../utils/stdin';
 import type { GmailAttachment } from '../types/gmail';
@@ -234,6 +234,49 @@ Query Syntax Examples:
       }
     });
 
+  gmail
+    .command('attachment <message-id>')
+    .description('Download attachments from a message')
+    .option('--profile <name>', 'Profile name')
+    .option('--name <filename>', 'Download specific attachment by filename (downloads all if not specified)')
+    .option('--output <dir>', 'Output directory', '.')
+    .action(async (messageId: string, options) => {
+      try {
+        const { client } = await getGmailClient(options.profile);
+        const outputDir = options.output;
+
+        // Download all attachments
+        const results = await client.getAllAttachments(messageId);
+
+        if (results.length === 0) {
+          console.log('No attachments found');
+          return;
+        }
+
+        // Filter by filename if specified
+        const toDownload = options.name
+          ? results.filter(({ attachment }) => attachment.filename === options.name)
+          : results;
+
+        if (toDownload.length === 0) {
+          throw new CliError('NOT_FOUND', `Attachment not found: ${options.name}`);
+        }
+
+        if (toDownload.length > 1) {
+          console.log(`Downloading ${toDownload.length} attachment(s)...\n`);
+        }
+
+        for (const { data, attachment } of toDownload) {
+          const outputPath = join(outputDir, attachment.filename);
+          await Bun.write(outputPath, data);
+          printAttachmentDownloaded(attachment.filename, outputPath, data.length);
+          if (toDownload.length > 1) console.log('');
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
   // Profile management
   const profile = gmail
     .command('profile')

package/src/services/gmail/client.ts

@@ -1,7 +1,7 @@
 import { google, gmail_v1 } from 'googleapis';
 import type { OAuth2Client } from 'google-auth-library';
 import { basename } from 'path';
-import type { GmailMessage, GmailListOptions, GmailSendOptions, GmailReplyOptions, GmailAttachment } from '../../types/gmail';
+import type { GmailMessage, GmailListOptions, GmailSendOptions, GmailReplyOptions, GmailAttachment, GmailAttachmentInfo } from '../../types/gmail';
 import { CliError } from '../../utils/errors';
 
 // Common MIME types by extension
@@ -64,7 +64,31 @@ export class GmailClient {
     return result;
   }
 
-  private parseMessage(message: gmail_v1.Schema$Message): GmailMessage {
+  private extractAttachments(payload: gmail_v1.Schema$MessagePart | undefined): GmailAttachmentInfo[] {
+    const attachments: GmailAttachmentInfo[] = [];
+
+    const processpart = (part: gmail_v1.Schema$MessagePart): void => {
+      if (part.filename && part.filename.length > 0 && part.body?.attachmentId) {
+        attachments.push({
+          id: part.body.attachmentId,
+          filename: part.filename,
+          mimeType: part.mimeType || 'application/octet-stream',
+          size: part.body.size || 0,
+        });
+      }
+      for (const child of part.parts || []) {
+        processpart(child);
+      }
+    };
+
+    if (payload) {
+      processpart(payload);
+    }
+
+    return attachments;
+  }
+
+  private parseMessage(message: gmail_v1.Schema$Message, includeAttachments: boolean = false): GmailMessage {
     const headers = this.parseHeaders(message.payload?.headers);
 
     const parseAddresses = (value?: string): string[] => {
@@ -72,7 +96,7 @@ export class GmailClient {
       return value.split(',').map((addr) => addr.trim());
     };
 
-    return {
+    const result: GmailMessage = {
       id: message.id!,
       threadId: message.threadId!,
       subject: headers['subject'] || '(no subject)',
@@ -83,6 +107,15 @@ export class GmailClient {
       snippet: message.snippet || '',
       labels: message.labelIds || [],
     };
+
+    if (includeAttachments) {
+      const attachments = this.extractAttachments(message.payload);
+      if (attachments.length > 0) {
+        result.attachments = attachments;
+      }
+    }
+
+    return result;
   }
 
   private getBody(payload: gmail_v1.Schema$MessagePart | undefined, preferHtml: boolean = false): string {
@@ -151,7 +184,7 @@ export class GmailClient {
         format: format === 'raw' ? 'raw' : 'full',
       });
 
-      const message = this.parseMessage(response.data);
+      const message = this.parseMessage(response.data, true);
       let body: string;
 
       if (format === 'raw') {
@@ -169,6 +202,47 @@ export class GmailClient {
     }
   }
 
+  async getAllAttachments(messageId: string): Promise<Array<{ data: Buffer; attachment: GmailAttachmentInfo }>> {
+    try {
+      const message = await this.gmail.users.messages.get({
+        userId: 'me',
+        id: messageId,
+        format: 'full',
+      });
+
+      const attachments = this.extractAttachments(message.data.payload);
+
+      if (attachments.length === 0) {
+        return [];
+      }
+
+      const results: Array<{ data: Buffer; attachment: GmailAttachmentInfo }> = [];
+
+      for (const attachment of attachments) {
+        const response = await this.gmail.users.messages.attachments.get({
+          userId: 'me',
+          messageId,
+          id: attachment.id,
+        });
+
+        if (response.data.data) {
+          results.push({
+            data: Buffer.from(response.data.data, 'base64'),
+            attachment,
+          });
+        }
+      }
+
+      return results;
+    } catch (error: any) {
+      if (error instanceof CliError) throw error;
+      if (error.code === 404) {
+        throw new CliError('NOT_FOUND', `Message not found: ${messageId}`);
+      }
+      throw new CliError('API_ERROR', `Gmail API error: ${error.message}`);
+    }
+  }
+
   async search(query: string, limit: number = 10): Promise<{ messages: GmailMessage[]; total: number }> {
     return this.list({ query, limit });
   }

package/src/types/gmail.ts

@@ -9,6 +9,7 @@ export interface GmailMessage {
   snippet: string;
   labels: string[];
   body?: string;
+  attachments?: GmailAttachmentInfo[];
 }
 
 export interface GmailListOptions {
@@ -23,6 +24,13 @@ export interface GmailAttachment {
   mimeType?: string;
 }
 
+export interface GmailAttachmentInfo {
+  id: string;
+  filename: string;
+  mimeType: string;
+  size: number;
+}
+
 export interface GmailSendOptions {
   to: string[];
   cc?: string[];

package/src/utils/output.ts

@@ -1,8 +1,16 @@
-import type { GmailMessage } from '../types/gmail';
+import type { GmailMessage, GmailAttachmentInfo } from '../types/gmail';
 import type { GChatMessage } from '../types/gchat';
 import type { JiraProject, JiraIssue, JiraTransition, JiraCommentResult, JiraTransitionResult } from '../types/jira';
 import type { SlackSendResult } from '../types/slack';
 
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
+
 // Format a list of Gmail messages
 export function printMessageList(messages: GmailMessage[], total: number): void {
   console.log(`Messages (${messages.length} of ~${total})\n`);
@@ -30,10 +38,41 @@ export function printMessage(msg: GmailMessage & { body: string }): void {
   console.log(`Date: ${msg.date}`);
   console.log(`Subject: ${msg.subject}`);
   if (msg.labels.length) console.log(`Labels: ${msg.labels.join(', ')}`);
+  if (msg.attachments && msg.attachments.length > 0) {
+    console.log(`Attachments: ${msg.attachments.length}`);
+    for (const att of msg.attachments) {
+      console.log(`  - ${att.filename} (${formatBytes(att.size)}) [${att.id}]`);
+    }
+  }
   console.log('---');
   console.log(msg.body);
 }
 
+// Format attachment list
+export function printAttachmentList(attachments: GmailAttachmentInfo[]): void {
+  if (attachments.length === 0) {
+    console.log('No attachments');
+    return;
+  }
+
+  console.log(`Attachments (${attachments.length})\n`);
+  for (let i = 0; i < attachments.length; i++) {
+    const att = attachments[i];
+    console.log(`[${i + 1}] ${att.filename}`);
+    console.log(`    Size: ${formatBytes(att.size)}`);
+    console.log(`    Type: ${att.mimeType}`);
+    console.log(`    ID: ${att.id}`);
+    console.log('');
+  }
+}
+
+// Format attachment download result
+export function printAttachmentDownloaded(filename: string, path: string, size: number): void {
+  console.log(`Downloaded: ${filename}`);
+  console.log(`  Path: ${path}`);
+  console.log(`  Size: ${formatBytes(size)}`);
+}
+
 // Format send/reply result
 export function printSendResult(result: { id: string; threadId: string }): void {
   console.log('Message sent');