npm - @plosson/agentio - Versions diffs - 0.5.10 → 0.5.13 - Mend

@plosson/agentio 0.5.10 → 0.5.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/package.json +1 -1
package/src/commands/gmail.ts +93 -85
package/src/services/gmail/client.ts +98 -68
package/src/types/gmail.ts +1 -6
package/src/utils/output.ts +7 -0

package/package.json CHANGED Viewed

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

package/src/commands/gmail.ts CHANGED Viewed

@@ -7,11 +7,94 @@ import { setProfile, getProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
 import { performOAuthFlow } from '../auth/oauth';
 import { GmailClient } from '../services/gmail/client';
-import { printMessageList, printMessage, printSendResult, printArchived, printMarked, printAttachmentList, printAttachmentDownloaded, raw } from '../utils/output';
+import { printMessageList, printMessage, printSendResult, printDraftResult, printArchived, printMarked, printAttachmentList, printAttachmentDownloaded, raw } from '../utils/output';
 import { CliError, handleError } from '../utils/errors';
 import { readStdin } from '../utils/stdin';
 import { enforceWriteAccess } from '../utils/read-only';
-import type { GmailAttachment } from '../types/gmail';
+import type { GmailAttachment, GmailSendOptions } from '../types/gmail';
+function addComposeOptions(cmd: Command): Command {
+  return cmd
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .option('--to <email>', 'Recipient (repeatable, required unless --reply-to)', (val: string, acc: string[]) => [...acc, val], [])
+    .option('--cc <email>', 'CC recipient (repeatable)', (val: string, acc: string[]) => [...acc, val], [])
+    .option('--bcc <email>', 'BCC recipient (repeatable)', (val: string, acc: string[]) => [...acc, val], [])
+    .option('--subject <subject>', 'Email subject (required unless --reply-to)')
+    .option('--body <body>', 'Email body (or pipe via stdin)')
+    .option('--html', 'Treat body as HTML')
+    .option('--reply-to <thread-id>', 'Thread ID to reply to (derives to/subject from thread)')
+    .option('--attachment <path>', 'File to attach (repeatable)', (val: string, acc: string[]) => [...acc, val], [])
+    .option('--inline <cid:path>', 'Inline image (repeatable, format: contentId:filepath). Supports PNG, JPG, GIF only (not SVG)', (val: string, acc: string[]) => [...acc, val], []);
+}
+async function parseBody(body: string | undefined): Promise<string> {
+  if (!body) {
+    body = await readStdin() ?? undefined;
+  }
+  if (!body) {
+    throw new CliError('INVALID_PARAMS', 'Body is required. Use --body or pipe via stdin.');
+  }
+  return body;
+}
+function parseAttachments(paths: string[]): GmailAttachment[] {
+  return paths.map((path: string) => ({
+    path,
+    filename: basename(path),
+  }));
+}
+function parseInlineAttachments(specs: string[]): GmailAttachment[] {
+  return specs.map((spec: string) => {
+    const colonIndex = spec.indexOf(':');
+    if (colonIndex === -1) {
+      throw new CliError('INVALID_PARAMS', `Invalid inline format: ${spec}`, 'Use format: contentId:filepath (e.g., logo:./logo.png)');
+    }
+    const contentId = spec.substring(0, colonIndex);
+    const path = spec.substring(colonIndex + 1);
+    return {
+      path,
+      filename: basename(path),
+      contentId,
+    };
+  });
+}
+async function parseSendOptions(options: Record<string, unknown>): Promise<GmailSendOptions> {
+  const replyTo = options.replyTo as string | undefined;
+  const to = options.to as string[];
+  const subject = options.subject as string | undefined;
+  if (!replyTo) {
+    if (!to.length) {
+      throw new CliError('INVALID_PARAMS', '--to is required (unless using --reply-to)');
+    }
+    if (!subject) {
+      throw new CliError('INVALID_PARAMS', '--subject is required (unless using --reply-to)');
+    }
+  }
+  const body = await parseBody(options.body as string | undefined);
+  const regularAttachments = parseAttachments(options.attachment as string[]);
+  const inlineAttachments = parseInlineAttachments(options.inline as string[]);
+  const attachments: GmailAttachment[] | undefined =
+    regularAttachments.length || inlineAttachments.length
+      ? [...regularAttachments, ...inlineAttachments]
+      : undefined;
+  return {
+    to,
+    cc: (options.cc as string[]).length ? options.cc as string[] : undefined,
+    bcc: (options.bcc as string[]).length ? options.bcc as string[] : undefined,
+    subject: subject || '',
+    body,
+    isHtml: options.html as boolean | undefined,
+    attachments,
+    replyTo,
+  };
+}
 function escapeHtml(text: string): string {
   return text
@@ -176,102 +259,27 @@ Query Syntax Examples:
       }
     });
-  gmail
-    .command('send')
-    .description('Send an email')
-    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
-    .requiredOption('--to <email>', 'Recipient (repeatable)', (val, acc: string[]) => [...acc, val], [])
-    .option('--cc <email>', 'CC recipient (repeatable)', (val, acc: string[]) => [...acc, val], [])
-    .option('--bcc <email>', 'BCC recipient (repeatable)', (val, acc: string[]) => [...acc, val], [])
-    .requiredOption('--subject <subject>', 'Email subject')
-    .option('--body <body>', 'Email body (or pipe via stdin)')
-    .option('--html', 'Treat body as HTML')
-    .option('--attachment <path>', 'File to attach (repeatable)', (val, acc: string[]) => [...acc, val], [])
-    .option('--inline <cid:path>', 'Inline image (repeatable, format: contentId:filepath). Supports PNG, JPG, GIF only (not SVG)', (val, acc: string[]) => [...acc, val], [])
+  addComposeOptions(gmail.command('send').description('Send an email'))
     .action(async (options) => {
       try {
-        let body = options.body;
-        // Check for stdin if no body provided
-        if (!body) {
-          body = await readStdin();
-        }
-        if (!body) {
-          throw new CliError('INVALID_PARAMS', 'Body is required. Use --body or pipe via stdin.');
-        }
-        // Process regular attachments
-        const regularAttachments: GmailAttachment[] = options.attachment.map((path: string) => ({
-          path,
-          filename: basename(path),
-        }));
-        // Process inline images (format: contentId:filepath)
-        const inlineAttachments: GmailAttachment[] = options.inline.map((spec: string) => {
-          const colonIndex = spec.indexOf(':');
-          if (colonIndex === -1) {
-            throw new CliError('INVALID_PARAMS', `Invalid inline format: ${spec}`, 'Use format: contentId:filepath (e.g., logo:./logo.png)');
-          }
-          const contentId = spec.substring(0, colonIndex);
-          const path = spec.substring(colonIndex + 1);
-          return {
-            path,
-            filename: basename(path),
-            contentId,
-          };
-        });
-        // Combine attachments
-        const attachments: GmailAttachment[] | undefined =
-          regularAttachments.length || inlineAttachments.length
-            ? [...regularAttachments, ...inlineAttachments]
-            : undefined;
+        const sendOptions = await parseSendOptions(options);
         const { client, profile } = await getGmailClient(options.profile);
         await enforceWriteAccess('gmail', profile, 'send email');
-        const result = await client.send({
-          to: options.to,
-          cc: options.cc.length ? options.cc : undefined,
-          bcc: options.bcc.length ? options.bcc : undefined,
-          subject: options.subject,
-          body,
-          isHtml: options.html,
-          attachments,
-        });
+        const result = await client.send(sendOptions);
         printSendResult(result);
       } catch (error) {
         handleError(error);
       }
     });
-  gmail
-    .command('reply')
-    .description('Reply to a thread')
-    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
-    .requiredOption('--thread-id <id>', 'Thread ID')
-    .option('--body <body>', 'Reply body (or pipe via stdin)')
-    .option('--html', 'Treat body as HTML')
+  addComposeOptions(gmail.command('draft').description('Create an email draft'))
     .action(async (options) => {
       try {
-        let body = options.body;
-        if (!body) {
-          body = await readStdin();
-        }
-        if (!body) {
-          throw new CliError('INVALID_PARAMS', 'Body is required. Use --body or pipe via stdin.');
-        }
+        const sendOptions = await parseSendOptions(options);
         const { client, profile } = await getGmailClient(options.profile);
-        await enforceWriteAccess('gmail', profile, 'reply to email');
-        const result = await client.reply({
-          threadId: options.threadId,
-          body,
-          isHtml: options.html,
-        });
-        printSendResult(result);
+        await enforceWriteAccess('gmail', profile, 'create draft');
+        const result = await client.draft(sendOptions);
+        printDraftResult(result);
       } catch (error) {
         handleError(error);
       }

package/src/services/gmail/client.ts CHANGED Viewed

@@ -1,10 +1,17 @@
 import { gmail, type gmail_v1 } from '@googleapis/gmail';
 import type { OAuth2Client } from 'google-auth-library';
 import { basename } from 'path';
-import type { GmailMessage, GmailListOptions, GmailSendOptions, GmailReplyOptions, GmailAttachment, GmailAttachmentInfo } from '../../types/gmail';
+import type { GmailMessage, GmailListOptions, GmailSendOptions, GmailAttachment, GmailAttachmentInfo } from '../../types/gmail';
 import type { ServiceClient, ValidationResult } from '../../types/service';
 import { CliError } from '../../utils/errors';
+// RFC 2047 encode a header value if it contains non-ASCII characters
+function encodeHeaderValue(value: string): string {
+  // eslint-disable-next-line no-control-regex
+  if (/^[\x00-\x7F]*$/.test(value)) return value;
+  return `=?UTF-8?B?${Buffer.from(value, 'utf-8').toString('base64')}?=`;
+}
 // Common MIME types by extension
 const MIME_TYPES: Record<string, string> = {
   '.txt': 'text/plain',
@@ -265,14 +272,57 @@ export class GmailClient implements ServiceClient {
     return this.list({ query, limit });
   }
-  async send(options: GmailSendOptions): Promise<{ id: string; threadId: string; labelIds: string[] }> {
-    const { to, cc, bcc, subject, body, isHtml, attachments } = options;
+  private async resolveReplyContext(threadId: string): Promise<{
+    to: string[];
+    subject: string;
+    extraHeaders: string[];
+  }> {
+    const thread = await this.gmail.users.threads.get({
+      userId: 'me',
+      id: threadId,
+    });
+    const messages = thread.data.messages || [];
+    if (messages.length === 0) {
+      throw new CliError('NOT_FOUND', `Thread not found: ${threadId}`);
+    }
+    const lastMessage = messages[messages.length - 1];
+    const headers = this.parseHeaders(lastMessage.payload?.headers);
+    const to = [headers['reply-to'] || headers['from'] || ''];
+    const subject = headers['subject']?.startsWith('Re:')
+      ? headers['subject']
+      : `Re: ${headers['subject'] || '(no subject)'}`;
+    const messageId = headers['message-id'] || '';
+    const extraHeaders: string[] = [];
+    if (messageId) {
+      extraHeaders.push(`In-Reply-To: ${messageId}`);
+      extraHeaders.push(`References: ${messageId}`);
+    }
+    return { to, subject, extraHeaders };
+  }
+  private async buildEncodedMessage(options: GmailSendOptions): Promise<string> {
+    const { cc, bcc, body, isHtml, attachments, replyTo } = options;
     const userEmail = await this.getUserEmail();
+    let to = options.to;
+    let subject = options.subject;
+    let extraHeaders: string[] | undefined;
+    if (replyTo) {
+      const replyContext = await this.resolveReplyContext(replyTo);
+      if (!to.length) to = replyContext.to;
+      if (!subject) subject = replyContext.subject;
+      extraHeaders = replyContext.extraHeaders;
+    }
     let rawMessage: string;
     if (attachments && attachments.length > 0) {
-      // Build multipart MIME message with attachments
       rawMessage = await this.buildMultipartMessage({
         from: userEmail,
         to,
@@ -282,27 +332,35 @@ export class GmailClient implements ServiceClient {
         body,
         isHtml,
         attachments,
+        extraHeaders,
       });
     } else {
-      // Simple message without attachments
       rawMessage = [
         `From: ${userEmail}`,
         `To: ${to.join(', ')}`,
         cc?.length ? `Cc: ${cc.join(', ')}` : null,
         bcc?.length ? `Bcc: ${bcc.join(', ')}` : null,
-        `Subject: ${subject}`,
+        `Subject: ${encodeHeaderValue(subject)}`,
+        ...(extraHeaders || []),
         `Content-Type: ${isHtml ? 'text/html' : 'text/plain'}; charset=utf-8`,
         '',
         body,
       ].filter((line): line is string => line !== null).join('\r\n');
     }
-    const encodedMessage = Buffer.from(rawMessage).toString('base64url');
+    return Buffer.from(rawMessage).toString('base64url');
+  }
+  async send(options: GmailSendOptions): Promise<{ id: string; threadId: string; labelIds: string[] }> {
+    const encodedMessage = await this.buildEncodedMessage(options);
     try {
       const response = await this.gmail.users.messages.send({
         userId: 'me',
-        requestBody: { raw: encodedMessage },
+        requestBody: {
+          raw: encodedMessage,
+          ...(options.replyTo ? { threadId: options.replyTo } : {}),
+        },
       });
       return {
@@ -316,6 +374,30 @@ export class GmailClient implements ServiceClient {
     }
   }
+  async draft(options: GmailSendOptions): Promise<{ id: string; messageId: string }> {
+    const encodedMessage = await this.buildEncodedMessage(options);
+    try {
+      const response = await this.gmail.users.drafts.create({
+        userId: 'me',
+        requestBody: {
+          message: {
+            raw: encodedMessage,
+            ...(options.replyTo ? { threadId: options.replyTo } : {}),
+          },
+        },
+      });
+      return {
+        id: response.data.id!,
+        messageId: response.data.message?.id || '',
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to create draft: ${message}`);
+    }
+  }
   private async buildMultipartMessage(options: {
     from: string;
     to: string[];
@@ -325,8 +407,9 @@ export class GmailClient implements ServiceClient {
     body: string;
     isHtml?: boolean;
     attachments: GmailAttachment[];
+    extraHeaders?: string[];
   }): Promise<string> {
-    const { from, to, cc, bcc, subject, body, isHtml, attachments } = options;
+    const { from, to, cc, bcc, subject, body, isHtml, attachments, extraHeaders } = options;
     // Separate inline and regular attachments
     const inlineAttachments = attachments.filter(a => a.contentId);
@@ -346,7 +429,12 @@ export class GmailClient implements ServiceClient {
     lines.push(`To: ${to.join(', ')}`);
     if (cc?.length) lines.push(`Cc: ${cc.join(', ')}`);
     if (bcc?.length) lines.push(`Bcc: ${bcc.join(', ')}`);
-    lines.push(`Subject: ${subject}`);
+    lines.push(`Subject: ${encodeHeaderValue(subject)}`);
+    if (extraHeaders) {
+      for (const header of extraHeaders) {
+        lines.push(header);
+      }
+    }
     lines.push('MIME-Version: 1.0');
     if (hasRegular && hasInline) {
@@ -464,64 +552,6 @@ export class GmailClient implements ServiceClient {
     }
   }
-  async reply(options: GmailReplyOptions): Promise<{ id: string; threadId: string; labelIds: string[] }> {
-    const { threadId, body, isHtml } = options;
-    // Get the thread to find the last message
-    try {
-      const thread = await this.gmail.users.threads.get({
-        userId: 'me',
-        id: threadId,
-      });
-      const messages = thread.data.messages || [];
-      if (messages.length === 0) {
-        throw new CliError('NOT_FOUND', `Thread not found: ${threadId}`);
-      }
-      const lastMessage = messages[messages.length - 1];
-      const headers = this.parseHeaders(lastMessage.payload?.headers);
-      const userEmail = await this.getUserEmail();
-      const replyTo = headers['reply-to'] || headers['from'] || '';
-      const subject = headers['subject']?.startsWith('Re:')
-        ? headers['subject']
-        : `Re: ${headers['subject'] || '(no subject)'}`;
-      const messageId = headers['message-id'] || '';
-      const rawHeaders = [
-        `From: ${userEmail}`,
-        `To: ${replyTo}`,
-        `Subject: ${subject}`,
-        messageId ? `In-Reply-To: ${messageId}` : '',
-        messageId ? `References: ${messageId}` : '',
-        `Content-Type: ${isHtml ? 'text/html' : 'text/plain'}; charset=utf-8`,
-        '',
-        body,
-      ].filter(Boolean).join('\r\n');
-      const encodedMessage = Buffer.from(rawHeaders).toString('base64url');
-      const response = await this.gmail.users.messages.send({
-        userId: 'me',
-        requestBody: {
-          raw: encodedMessage,
-          threadId,
-        },
-      });
-      return {
-        id: response.data.id!,
-        threadId: response.data.threadId!,
-        labelIds: response.data.labelIds || ['SENT'],
-      };
-    } catch (error) {
-      if (error instanceof CliError) throw error;
-      const message = error instanceof Error ? error.message : String(error);
-      throw new CliError('API_ERROR', `Failed to send reply: ${message}`);
-    }
-  }
   async archive(messageId: string): Promise<void> {
     try {
       await this.gmail.users.messages.modify({

package/src/types/gmail.ts CHANGED Viewed

@@ -40,10 +40,5 @@ export interface GmailSendOptions {
   body: string;
   isHtml?: boolean;
   attachments?: GmailAttachment[];
-}
-export interface GmailReplyOptions {
-  threadId: string;
-  body: string;
-  isHtml?: boolean;
+  replyTo?: string; // Thread ID to reply to
 }

package/src/utils/output.ts CHANGED Viewed

@@ -86,6 +86,13 @@ export function printSendResult(result: { id: string; threadId: string }): void
   console.log(`Thread: ${result.threadId}`);
 }
+// Format draft creation result
+export function printDraftResult(result: { id: string; messageId: string }): void {
+  console.log('Draft created');
+  console.log(`Draft ID: ${result.id}`);
+  console.log(`Message ID: ${result.messageId}`);
+}
 // Format archive confirmation
 export function printArchived(messageId: string): void {
   console.log(`Archived: ${messageId}`);