@plosson/agentio 0.1.0

package/src/services/gmail/client.ts

@@ -0,0 +1,377 @@
+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 { CliError } from '../../utils/errors';
+
+// Common MIME types by extension
+const MIME_TYPES: Record<string, string> = {
+  '.txt': 'text/plain',
+  '.html': 'text/html',
+  '.css': 'text/css',
+  '.js': 'application/javascript',
+  '.json': 'application/json',
+  '.xml': 'application/xml',
+  '.pdf': 'application/pdf',
+  '.zip': 'application/zip',
+  '.gz': 'application/gzip',
+  '.tar': 'application/x-tar',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+  '.mp3': 'audio/mpeg',
+  '.mp4': 'video/mp4',
+  '.wav': 'audio/wav',
+  '.doc': 'application/msword',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.xls': 'application/vnd.ms-excel',
+  '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  '.ppt': 'application/vnd.ms-powerpoint',
+  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+};
+
+function getMimeType(filename: string): string {
+  const ext = filename.toLowerCase().match(/\.[^.]+$/)?.[0] || '';
+  return MIME_TYPES[ext] || 'application/octet-stream';
+}
+
+export class GmailClient {
+  private gmail: gmail_v1.Gmail;
+  private userEmail: string | null = null;
+
+  constructor(auth: OAuth2Client) {
+    this.gmail = google.gmail({ version: 'v1', auth });
+  }
+
+  private async getUserEmail(): Promise<string> {
+    if (this.userEmail) return this.userEmail;
+
+    const profile = await this.gmail.users.getProfile({ userId: 'me' });
+    this.userEmail = profile.data.emailAddress || 'me';
+    return this.userEmail;
+  }
+
+  private parseHeaders(headers: gmail_v1.Schema$MessagePartHeader[] | undefined): Record<string, string> {
+    const result: Record<string, string> = {};
+    for (const header of headers || []) {
+      if (header.name && header.value) {
+        result[header.name.toLowerCase()] = header.value;
+      }
+    }
+    return result;
+  }
+
+  private parseMessage(message: gmail_v1.Schema$Message): GmailMessage {
+    const headers = this.parseHeaders(message.payload?.headers);
+
+    const parseAddresses = (value?: string): string[] => {
+      if (!value) return [];
+      return value.split(',').map((addr) => addr.trim());
+    };
+
+    return {
+      id: message.id!,
+      threadId: message.threadId!,
+      subject: headers['subject'] || '(no subject)',
+      from: headers['from'] || '',
+      to: parseAddresses(headers['to']),
+      cc: parseAddresses(headers['cc']),
+      date: headers['date'] || '',
+      snippet: message.snippet || '',
+      labels: message.labelIds || [],
+    };
+  }
+
+  private getBody(payload: gmail_v1.Schema$MessagePart | undefined, preferHtml: boolean = false): string {
+    if (!payload) return '';
+
+    const findPart = (part: gmail_v1.Schema$MessagePart, mimeType: string): string | null => {
+      if (part.mimeType === mimeType && part.body?.data) {
+        return Buffer.from(part.body.data, 'base64').toString('utf-8');
+      }
+      for (const child of part.parts || []) {
+        const result = findPart(child, mimeType);
+        if (result) return result;
+      }
+      return null;
+    };
+
+    const targetMime = preferHtml ? 'text/html' : 'text/plain';
+    const fallbackMime = preferHtml ? 'text/plain' : 'text/html';
+
+    return findPart(payload, targetMime) || findPart(payload, fallbackMime) || '';
+  }
+
+  async list(options: GmailListOptions = {}): Promise<{ messages: GmailMessage[]; total: number }> {
+    const { limit = 10, query, labels } = options;
+
+    let q = query || '';
+    if (labels?.length) {
+      q += ' ' + labels.map((l) => `label:${l}`).join(' ');
+    }
+
+    try {
+      const response = await this.gmail.users.messages.list({
+        userId: 'me',
+        maxResults: Math.min(limit, 100),
+        q: q.trim() || undefined,
+      });
+
+      const messageIds = response.data.messages || [];
+      const messages: GmailMessage[] = [];
+
+      for (const { id } of messageIds) {
+        if (!id) continue;
+        const msg = await this.gmail.users.messages.get({
+          userId: 'me',
+          id,
+          format: 'metadata',
+          metadataHeaders: ['From', 'To', 'Cc', 'Subject', 'Date'],
+        });
+        messages.push(this.parseMessage(msg.data));
+      }
+
+      return {
+        messages,
+        total: response.data.resultSizeEstimate || messages.length,
+      };
+    } catch (error: any) {
+      throw new CliError('API_ERROR', `Gmail API error: ${error.message}`);
+    }
+  }
+
+  async get(messageId: string, format: 'text' | 'html' | 'raw' = 'text'): Promise<GmailMessage & { body: string }> {
+    try {
+      const response = await this.gmail.users.messages.get({
+        userId: 'me',
+        id: messageId,
+        format: format === 'raw' ? 'raw' : 'full',
+      });
+
+      const message = this.parseMessage(response.data);
+      let body: string;
+
+      if (format === 'raw') {
+        body = response.data.raw ? Buffer.from(response.data.raw, 'base64').toString('utf-8') : '';
+      } else {
+        body = this.getBody(response.data.payload, format === 'html');
+      }
+
+      return { ...message, body };
+    } catch (error: any) {
+      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 });
+  }
+
+  async send(options: GmailSendOptions): Promise<{ id: string; threadId: string; labelIds: string[] }> {
+    const { to, cc, bcc, subject, body, isHtml, attachments } = options;
+    const userEmail = await this.getUserEmail();
+
+    let rawMessage: string;
+
+    if (attachments && attachments.length > 0) {
+      // Build multipart MIME message with attachments
+      rawMessage = await this.buildMultipartMessage({
+        from: userEmail,
+        to,
+        cc,
+        bcc,
+        subject,
+        body,
+        isHtml,
+        attachments,
+      });
+    } 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}`,
+        `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');
+
+    try {
+      const response = await this.gmail.users.messages.send({
+        userId: 'me',
+        requestBody: { raw: encodedMessage },
+      });
+
+      return {
+        id: response.data.id!,
+        threadId: response.data.threadId!,
+        labelIds: response.data.labelIds || ['SENT'],
+      };
+    } catch (error: any) {
+      throw new CliError('API_ERROR', `Failed to send email: ${error.message}`);
+    }
+  }
+
+  private async buildMultipartMessage(options: {
+    from: string;
+    to: string[];
+    cc?: string[];
+    bcc?: string[];
+    subject: string;
+    body: string;
+    isHtml?: boolean;
+    attachments: GmailAttachment[];
+  }): Promise<string> {
+    const { from, to, cc, bcc, subject, body, isHtml, attachments } = options;
+    const boundary = `----=_Part_${Date.now()}_${Math.random().toString(36).substring(2)}`;
+
+    const headers = [
+      `From: ${from}`,
+      `To: ${to.join(', ')}`,
+      cc?.length ? `Cc: ${cc.join(', ')}` : null,
+      bcc?.length ? `Bcc: ${bcc.join(', ')}` : null,
+      `Subject: ${subject}`,
+      'MIME-Version: 1.0',
+      `Content-Type: multipart/mixed; boundary="${boundary}"`,
+      '',
+      `--${boundary}`,
+      `Content-Type: ${isHtml ? 'text/html' : 'text/plain'}; charset=utf-8`,
+      '',
+      body,
+    ].filter((line): line is string => line !== null);
+
+    // Add attachments
+    for (const attachment of attachments) {
+      try {
+        const file = Bun.file(attachment.path);
+        const exists = await file.exists();
+        if (!exists) {
+          throw new CliError('NOT_FOUND', `Attachment not found: ${attachment.path}`);
+        }
+
+        const content = await file.arrayBuffer();
+        const base64Content = Buffer.from(content).toString('base64');
+        const filename = attachment.filename || basename(attachment.path);
+        const mimeType = attachment.mimeType || getMimeType(filename);
+
+        headers.push(
+          `--${boundary}`,
+          `Content-Type: ${mimeType}; name="${filename}"`,
+          'Content-Transfer-Encoding: base64',
+          `Content-Disposition: attachment; filename="${filename}"`,
+          '',
+          base64Content
+        );
+      } catch (error: any) {
+        if (error instanceof CliError) throw error;
+        throw new CliError('API_ERROR', `Failed to read attachment ${attachment.path}: ${error.message}`);
+      }
+    }
+
+    headers.push(`--${boundary}--`);
+
+    return headers.join('\r\n');
+  }
+
+  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: any) {
+      if (error instanceof CliError) throw error;
+      throw new CliError('API_ERROR', `Failed to send reply: ${error.message}`);
+    }
+  }
+
+  async archive(messageId: string): Promise<void> {
+    try {
+      await this.gmail.users.messages.modify({
+        userId: 'me',
+        id: messageId,
+        requestBody: {
+          removeLabelIds: ['INBOX'],
+        },
+      });
+    } catch (error: any) {
+      if (error.code === 404) {
+        throw new CliError('NOT_FOUND', `Message not found: ${messageId}`);
+      }
+      throw new CliError('API_ERROR', `Failed to archive: ${error.message}`);
+    }
+  }
+
+  async mark(messageId: string, read: boolean): Promise<void> {
+    try {
+      await this.gmail.users.messages.modify({
+        userId: 'me',
+        id: messageId,
+        requestBody: read
+          ? { removeLabelIds: ['UNREAD'] }
+          : { addLabelIds: ['UNREAD'] },
+      });
+    } catch (error: any) {
+      if (error.code === 404) {
+        throw new CliError('NOT_FOUND', `Message not found: ${messageId}`);
+      }
+      throw new CliError('API_ERROR', `Failed to update message: ${error.message}`);
+    }
+  }
+}

package/src/services/telegram/client.ts

@@ -0,0 +1,81 @@
+import type { TelegramBotInfo, TelegramChat, TelegramMessage, TelegramSendOptions } from '../../types/telegram';
+import { CliError } from '../../utils/errors';
+
+const TELEGRAM_API_BASE = 'https://api.telegram.org/bot';
+
+interface TelegramApiResponse<T> {
+  ok: boolean;
+  result?: T;
+  description?: string;
+  error_code?: number;
+}
+
+export class TelegramClient {
+  private baseUrl: string;
+
+  constructor(
+    private botToken: string,
+    private channelId: string
+  ) {
+    this.baseUrl = `${TELEGRAM_API_BASE}${botToken}`;
+  }
+
+  private async request<T>(method: string, params?: Record<string, unknown>): Promise<T> {
+    const url = `${this.baseUrl}/${method}`;
+
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: params ? JSON.stringify(params) : undefined,
+      });
+
+      const data = (await response.json()) as TelegramApiResponse<T>;
+
+      if (!data.ok) {
+        const errorMessage = data.description || 'Unknown Telegram API error';
+
+        if (data.error_code === 401) {
+          throw new CliError('AUTH_FAILED', `Invalid bot token: ${errorMessage}`);
+        }
+        if (data.error_code === 403) {
+          throw new CliError('PERMISSION_DENIED', `Bot cannot access channel: ${errorMessage}`);
+        }
+        if (data.error_code === 404) {
+          throw new CliError('NOT_FOUND', `Channel not found: ${errorMessage}`);
+        }
+        if (data.error_code === 429) {
+          throw new CliError('RATE_LIMITED', `Rate limited: ${errorMessage}`);
+        }
+
+        throw new CliError('API_ERROR', `Telegram API error: ${errorMessage}`);
+      }
+
+      return data.result!;
+    } catch (error) {
+      if (error instanceof CliError) throw error;
+
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      throw new CliError('NETWORK_ERROR', `Failed to connect to Telegram: ${message}`);
+    }
+  }
+
+  async getMe(): Promise<TelegramBotInfo> {
+    return this.request<TelegramBotInfo>('getMe');
+  }
+
+  async getChat(chatId?: string): Promise<TelegramChat> {
+    return this.request<TelegramChat>('getChat', {
+      chat_id: chatId || this.channelId,
+    });
+  }
+
+  async sendMessage(text: string, options?: TelegramSendOptions): Promise<TelegramMessage> {
+    return this.request<TelegramMessage>('sendMessage', {
+      chat_id: this.channelId,
+      text,
+      parse_mode: options?.parse_mode,
+      disable_notification: options?.disable_notification,
+    });
+  }
+}

package/src/types/config.ts

@@ -0,0 +1,16 @@
+export interface Config {
+  profiles: {
+    gmail?: string[];
+    gchat?: string[];
+    jira?: string[];
+    telegram?: string[];
+  };
+  defaults: {
+    gmail?: string;
+    gchat?: string;
+    jira?: string;
+    telegram?: string;
+  };
+}
+
+export type ServiceName = 'gmail' | 'gchat' | 'jira' | 'telegram';

package/src/types/gmail.ts

@@ -0,0 +1,40 @@
+export interface GmailMessage {
+  id: string;
+  threadId: string;
+  subject: string;
+  from: string;
+  to: string[];
+  cc: string[];
+  date: string;
+  snippet: string;
+  labels: string[];
+  body?: string;
+}
+
+export interface GmailListOptions {
+  limit?: number;
+  query?: string;
+  labels?: string[];
+}
+
+export interface GmailAttachment {
+  filename: string;
+  path: string;
+  mimeType?: string;
+}
+
+export interface GmailSendOptions {
+  to: string[];
+  cc?: string[];
+  bcc?: string[];
+  subject: string;
+  body: string;
+  isHtml?: boolean;
+  attachments?: GmailAttachment[];
+}
+
+export interface GmailReplyOptions {
+  threadId: string;
+  body: string;
+  isHtml?: boolean;
+}

package/src/types/telegram.ts

@@ -0,0 +1,34 @@
+export interface TelegramCredentials {
+  bot_token: string;
+  channel_id: string;
+  bot_username?: string;
+}
+
+export interface TelegramBotInfo {
+  id: number;
+  is_bot: boolean;
+  first_name: string;
+  username: string;
+  can_join_groups: boolean;
+  can_read_all_group_messages: boolean;
+  supports_inline_queries: boolean;
+}
+
+export interface TelegramChat {
+  id: number;
+  type: 'private' | 'group' | 'supergroup' | 'channel';
+  title?: string;
+  username?: string;
+}
+
+export interface TelegramMessage {
+  message_id: number;
+  chat: TelegramChat;
+  date: number;
+  text?: string;
+}
+
+export interface TelegramSendOptions {
+  parse_mode?: 'HTML' | 'Markdown' | 'MarkdownV2';
+  disable_notification?: boolean;
+}

package/src/types/tokens.ts

@@ -0,0 +1,13 @@
+export interface OAuthTokens {
+  access_token: string;
+  refresh_token?: string;
+  expiry_date?: number;
+  token_type: string;
+  scope?: string;
+}
+
+export interface StoredCredentials {
+  [service: string]: {
+    [profile: string]: Record<string, unknown>;
+  };
+}

package/src/utils/errors.ts

@@ -0,0 +1,60 @@
+export type ErrorCode =
+  | 'AUTH_FAILED'
+  | 'TOKEN_EXPIRED'
+  | 'PROFILE_NOT_FOUND'
+  | 'INVALID_PARAMS'
+  | 'API_ERROR'
+  | 'NETWORK_ERROR'
+  | 'PERMISSION_DENIED'
+  | 'RATE_LIMITED'
+  | 'NOT_FOUND'
+  | 'CONFIG_ERROR';
+
+export class CliError extends Error {
+  constructor(
+    public code: ErrorCode,
+    message: string,
+    public suggestion?: string
+  ) {
+    super(message);
+    this.name = 'CliError';
+  }
+}
+
+export function exitCodeForError(code: ErrorCode): number {
+  switch (code) {
+    case 'AUTH_FAILED':
+    case 'TOKEN_EXPIRED':
+    case 'PERMISSION_DENIED':
+      return 2;
+    case 'CONFIG_ERROR':
+    case 'PROFILE_NOT_FOUND':
+      return 3;
+    case 'NETWORK_ERROR':
+      return 4;
+    case 'API_ERROR':
+    case 'RATE_LIMITED':
+    case 'NOT_FOUND':
+      return 5;
+    default:
+      return 1;
+  }
+}
+
+export function handleError(error: unknown): never {
+  if (error instanceof CliError) {
+    console.error(`Error [${error.code}]: ${error.message}`);
+    if (error.suggestion) {
+      console.error(`Suggestion: ${error.suggestion}`);
+    }
+    process.exit(exitCodeForError(error.code));
+  }
+
+  if (error instanceof Error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+
+  console.error('An unexpected error occurred');
+  process.exit(1);
+}

package/src/utils/output.ts

@@ -0,0 +1,54 @@
+import type { GmailMessage } from '../types/gmail';
+
+// Format a list of Gmail messages
+export function printMessageList(messages: GmailMessage[], total: number): void {
+  console.log(`Messages (${messages.length} of ~${total})\n`);
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    console.log(`[${i + 1}] ${msg.id} | thread:${msg.threadId}`);
+    console.log(`    From: ${msg.from}`);
+    if (msg.to.length) console.log(`    To: ${msg.to.join(', ')}`);
+    console.log(`    Date: ${msg.date}`);
+    console.log(`    Subject: ${msg.subject}`);
+    if (msg.labels.length) console.log(`    Labels: ${msg.labels.join(', ')}`);
+    if (msg.snippet) console.log(`    > ${msg.snippet}`);
+    console.log('');
+  }
+}
+
+// Format a single Gmail message with body
+export function printMessage(msg: GmailMessage & { body: string }): void {
+  console.log(`ID: ${msg.id}`);
+  console.log(`Thread: ${msg.threadId}`);
+  console.log(`From: ${msg.from}`);
+  if (msg.to.length) console.log(`To: ${msg.to.join(', ')}`);
+  if (msg.cc.length) console.log(`CC: ${msg.cc.join(', ')}`);
+  console.log(`Date: ${msg.date}`);
+  console.log(`Subject: ${msg.subject}`);
+  if (msg.labels.length) console.log(`Labels: ${msg.labels.join(', ')}`);
+  console.log('---');
+  console.log(msg.body);
+}
+
+// Format send/reply result
+export function printSendResult(result: { id: string; threadId: string }): void {
+  console.log('Message sent');
+  console.log(`ID: ${result.id}`);
+  console.log(`Thread: ${result.threadId}`);
+}
+
+// Format archive confirmation
+export function printArchived(messageId: string): void {
+  console.log(`Archived: ${messageId}`);
+}
+
+// Format mark read/unread confirmation
+export function printMarked(messageId: string, read: boolean): void {
+  console.log(`Marked ${messageId} as ${read ? 'read' : 'unread'}`);
+}
+
+// Output raw text (for body-only mode)
+export function raw(text: string): void {
+  console.log(text);
+}

package/src/utils/stdin.ts

@@ -0,0 +1,18 @@
+export async function readStdin(): Promise<string | null> {
+  // Check if stdin is a TTY (interactive terminal)
+  if (process.stdin.isTTY) {
+    return null;
+  }
+
+  const chunks: Buffer[] = [];
+
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+
+  if (chunks.length === 0) {
+    return null;
+  }
+
+  return Buffer.concat(chunks).toString('utf-8').trim();
+}