@plosson/agentio 0.5.9 → 0.5.12

package/package.json

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

package/src/commands/gateway.ts

@@ -7,7 +7,7 @@ import { password } from '@inquirer/prompts';
 import { handleError, CliError } from '../utils/errors';
 import { loadConfig, saveConfig } from '../config/config-manager';
 import { startGateway, getGatewayConfig, LOG_FILE } from '../gateway/daemon';
-import { exportWhatsAppAuthState } from '../gateway/store';
+import { initDatabase, closeDatabase, exportWhatsAppAuthState } from '../gateway/store';
 import { isInteractive } from '../utils/interactive';
 import type { Config } from '../types/config';
 
@@ -518,32 +518,40 @@ export function registerGatewayCommands(program: Command): void {
         if (options.service === 'all' || options.service === 'whatsapp') {
           const profiles = config.profiles.whatsapp || [];
 
-          for (const entry of profiles) {
-            const profileName = typeof entry === 'string' ? entry : entry.name;
-            console.log(`  Exporting whatsapp:${profileName}...`);
-            const authState = await exportWhatsAppAuthState(profileName);
+          if (profiles.length > 0) {
+            await initDatabase();
+          }
 
-            if (!authState) {
-              console.log('    No auth state found, skipping');
-              continue;
-            }
+          try {
+            for (const entry of profiles) {
+              const profileName = typeof entry === 'string' ? entry : entry.name;
+              console.log(`  Exporting whatsapp:${profileName}...`);
+              const authState = await exportWhatsAppAuthState(profileName);
 
-            // Send to remote gateway
-            const response = await fetch(`${url}/import/whatsapp/${encodeURIComponent(profileName)}`, {
-              method: 'POST',
-              headers: {
-                'Content-Type': 'application/json',
-                'X-API-Key': key,
-              },
-              body: JSON.stringify(authState),
-            });
-
-            if (!response.ok) {
-              const error = await response.text();
-              throw new CliError('API_ERROR', `Failed to import to remote: ${error}`);
-            }
+              if (!authState) {
+                console.log('    No auth state found, skipping');
+                continue;
+              }
 
-            console.log('    Transferred successfully');
+              // Send to remote gateway
+              const response = await fetch(`${url}/import/whatsapp/${encodeURIComponent(profileName)}`, {
+                method: 'POST',
+                headers: {
+                  'Content-Type': 'application/json',
+                  'X-API-Key': key,
+                },
+                body: JSON.stringify(authState),
+              });
+
+              if (!response.ok) {
+                const error = await response.text();
+                throw new CliError('API_ERROR', `Failed to import to remote: ${error}`);
+              }
+
+              console.log('    Transferred successfully');
+            }
+          } finally {
+            closeDatabase();
           }
         }
 

package/src/commands/gmail.ts

@@ -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/gateway/adapters/whatsapp.ts

@@ -75,6 +75,10 @@ export class WhatsAppAdapter extends BaseAdapter {
 
   private profiles: Map<string, ProfileConnection> = new Map();
 
+  hasProfile(profile: string): boolean {
+    return this.profiles.has(profile);
+  }
+
   async connect(profile: string, credentials: unknown): Promise<void> {
     const creds = credentials as WhatsAppCredentials;
 

package/src/gateway/api.ts

@@ -52,13 +52,31 @@ import {
   importWhatsAppAuthState,
   type WhatsAppAuthExport,
 } from './store';
-import type { ServiceAdapter } from './adapters/types';
-import type { WhatsAppAdapter } from './adapters/whatsapp';
+import type { ServiceAdapter, AdapterInboundMessage } from './adapters/types';
+import { WhatsAppAdapter } from './adapters/whatsapp';
 
 let server: Server<unknown> | null = null;
 let apiKey: string = '';
 let startTime: number = 0;
 let adapters: Map<ServiceName, ServiceAdapter> = new Map();
+let onAdapterMessage: ((service: ServiceName, profile: string, message: AdapterInboundMessage) => void) | null = null;
+
+/**
+ * Get or lazily create the WhatsApp adapter
+ */
+function getOrCreateWhatsAppAdapter(): WhatsAppAdapter {
+  let adapter = adapters.get('whatsapp') as WhatsAppAdapter | undefined;
+  if (!adapter) {
+    adapter = new WhatsAppAdapter();
+    adapter.onMessage = (profile, message) => {
+      if (onAdapterMessage) {
+        onAdapterMessage('whatsapp', profile, message);
+      }
+    };
+    adapters.set('whatsapp', adapter);
+  }
+  return adapter;
+}
 
 /**
  * JSON error response helper
@@ -333,19 +351,39 @@ function handleMedia(id: string): Response {
 /**
  * Handle WhatsApp pairing request
  */
-function handleWhatsAppPair(profile: string): Response {
-  const whatsappAdapter = adapters.get('whatsapp') as WhatsAppAdapter | undefined;
+async function handleWhatsAppPair(profile: string): Promise<Response> {
+  const whatsappAdapter = getOrCreateWhatsAppAdapter();
 
-  if (!whatsappAdapter) {
+  // If the profile isn't known to the adapter yet, start connecting it
+  const state = whatsappAdapter.getWhatsAppState(profile);
+  if (!state.connected && !whatsappAdapter.hasProfile(profile)) {
+    try {
+      await whatsappAdapter.connect(profile, { paired: false });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Failed to start pairing';
+      const response: WhatsAppPairResponse = {
+        status: 'connecting',
+        message,
+      };
+      return jsonResponse(response);
+    }
+    // Re-check state after connect
+    const newState = whatsappAdapter.getWhatsAppState(profile);
+    if (newState.qrCode) {
+      const response: WhatsAppPairResponse = {
+        status: 'waiting_qr',
+        qrCode: newState.qrCode,
+        message: 'Scan QR code with WhatsApp on your phone',
+      };
+      return jsonResponse(response);
+    }
     const response: WhatsAppPairResponse = {
-      status: 'not_configured',
-      message: 'WhatsApp is not configured. Add a profile first.',
+      status: 'connecting',
+      message: newState.error || 'Connecting to WhatsApp...',
     };
     return jsonResponse(response);
   }
 
-  const state = whatsappAdapter.getWhatsAppState(profile);
-
   if (state.connected) {
     const response: WhatsAppPairResponse = {
       status: 'connected',
@@ -390,13 +428,14 @@ async function handleWhatsAppImport(profile: string, request: Request): Promise<
     });
 
     // Disconnect and reconnect WhatsApp adapter to use new credentials
-    const whatsappAdapter = adapters.get('whatsapp') as WhatsAppAdapter | undefined;
-    if (whatsappAdapter) {
+    const whatsappAdapter = getOrCreateWhatsAppAdapter();
+    if (whatsappAdapter.hasProfile(profile)) {
       await whatsappAdapter.disconnect(profile);
-      // Note: reconnection will happen on next daemon cycle or manual reload
     }
+    // Reconnect with imported auth state
+    await whatsappAdapter.connect(profile, { paired: true });
 
-    return jsonResponse({ success: true, message: 'Auth state imported. Reload gateway to reconnect.' });
+    return jsonResponse({ success: true, message: 'Auth state imported and reconnecting.' });
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Import failed';
     return jsonError(message, 500);
@@ -753,12 +792,17 @@ async function handleRequest(request: Request): Promise<Response> {
 /**
  * Start the API server
  */
-export function startApiServer(config: GatewayConfig, serviceAdapters: Map<ServiceName, ServiceAdapter>): Server<unknown> {
+export function startApiServer(
+  config: GatewayConfig,
+  serviceAdapters: Map<ServiceName, ServiceAdapter>,
+  messageHandler?: (service: ServiceName, profile: string, message: AdapterInboundMessage) => void,
+): Server<unknown> {
   const port = config?.server?.port ?? DEFAULT_GATEWAY_CONFIG.server.port;
   const host = config?.server?.host ?? DEFAULT_GATEWAY_CONFIG.server.host;
   apiKey = config?.apiKey ?? '';
   startTime = Date.now();
   adapters = serviceAdapters;
+  onAdapterMessage = messageHandler ?? null;
 
   server = Bun.serve({
     port,

package/src/gateway/daemon.ts

@@ -274,7 +274,7 @@ export async function startGateway(): Promise<void> {
     await initializeAdapters();
 
     // Start API server
-    startApiServer(gatewayConfig, adapters);
+    startApiServer(gatewayConfig, adapters, handleInboundMessage);
 
     // Start outbox processor (every 2 seconds)
     outboxInterval = setInterval(processOutbox, 2000);

package/src/services/gmail/client.ts

@@ -1,7 +1,7 @@
 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';
 
@@ -265,14 +265,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 +325,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}`,
+        ...(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 +367,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 +400,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);
@@ -347,6 +423,11 @@ export class GmailClient implements ServiceClient {
     if (cc?.length) lines.push(`Cc: ${cc.join(', ')}`);
     if (bcc?.length) lines.push(`Bcc: ${bcc.join(', ')}`);
     lines.push(`Subject: ${subject}`);
+    if (extraHeaders) {
+      for (const header of extraHeaders) {
+        lines.push(header);
+      }
+    }
     lines.push('MIME-Version: 1.0');
 
     if (hasRegular && hasInline) {
@@ -464,64 +545,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

@@ -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

@@ -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}`);