@plosson/agentio 0.1.26 → 0.1.28

package/src/services/gmail/client.ts

@@ -2,6 +2,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, GmailAttachmentInfo } from '../../types/gmail';
+import type { ServiceClient, ValidationResult } from '../../types/service';
 import { CliError } from '../../utils/errors';
 
 // Common MIME types by extension
@@ -38,7 +39,7 @@ function getMimeType(filename: string): string {
   return MIME_TYPES[ext] || 'application/octet-stream';
 }
 
-export class GmailClient {
+export class GmailClient implements ServiceClient {
   private gmail: gmail_v1.Gmail;
   private userEmail: string | null = null;
 
@@ -46,6 +47,20 @@ export class GmailClient {
     this.gmail = google.gmail({ version: 'v1', auth });
   }
 
+  async validate(): Promise<ValidationResult> {
+    try {
+      const email = await this.getUserEmail();
+      return { valid: true, info: email };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      // Check if it's a refresh failure
+      if (message.includes('invalid_grant') || message.includes('Token has been expired or revoked')) {
+        return { valid: false, error: 'refresh token expired, re-authenticate' };
+      }
+      return { valid: false, error: message };
+    }
+  }
+
   private async getUserEmail(): Promise<string> {
     if (this.userEmail) return this.userEmail;
 
@@ -308,54 +323,140 @@ export class GmailClient {
     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}`);
+    // Separate inline and regular attachments
+    const inlineAttachments = attachments.filter(a => a.contentId);
+    const regularAttachments = attachments.filter(a => !a.contentId);
+
+    const hasInline = inlineAttachments.length > 0;
+    const hasRegular = regularAttachments.length > 0;
+
+    // Generate boundaries
+    const mixedBoundary = `----=_Mixed_${Date.now()}_${Math.random().toString(36).substring(2)}`;
+    const relatedBoundary = `----=_Related_${Date.now()}_${Math.random().toString(36).substring(2)}`;
+
+    const lines: string[] = [];
+
+    // Email headers
+    lines.push(`From: ${from}`);
+    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('MIME-Version: 1.0');
+
+    if (hasRegular && hasInline) {
+      // Both: multipart/mixed containing multipart/related + regular attachments
+      lines.push(`Content-Type: multipart/mixed; boundary="${mixedBoundary}"`);
+      lines.push('');
+      lines.push(`--${mixedBoundary}`);
+      lines.push(`Content-Type: multipart/related; boundary="${relatedBoundary}"`);
+      lines.push('');
+
+      // HTML body
+      lines.push(`--${relatedBoundary}`);
+      lines.push(`Content-Type: ${isHtml ? 'text/html' : 'text/plain'}; charset=utf-8`);
+      lines.push('');
+      lines.push(body);
+
+      // Inline images
+      for (const attachment of inlineAttachments) {
+        const encoded = await this.encodeAttachment(attachment);
+        lines.push(`--${relatedBoundary}`);
+        lines.push(`Content-Type: ${encoded.mimeType}; name="${encoded.filename}"`);
+        lines.push('Content-Transfer-Encoding: base64');
+        lines.push(`Content-ID: <${attachment.contentId}>`);
+        lines.push(`Content-Disposition: inline; filename="${encoded.filename}"`);
+        lines.push('');
+        lines.push(encoded.base64);
+      }
+      lines.push(`--${relatedBoundary}--`);
+
+      // Regular attachments
+      for (const attachment of regularAttachments) {
+        const encoded = await this.encodeAttachment(attachment);
+        lines.push(`--${mixedBoundary}`);
+        lines.push(`Content-Type: ${encoded.mimeType}; name="${encoded.filename}"`);
+        lines.push('Content-Transfer-Encoding: base64');
+        lines.push(`Content-Disposition: attachment; filename="${encoded.filename}"`);
+        lines.push('');
+        lines.push(encoded.base64);
+      }
+      lines.push(`--${mixedBoundary}--`);
+
+    } else if (hasInline) {
+      // Only inline: multipart/related
+      lines.push(`Content-Type: multipart/related; boundary="${relatedBoundary}"`);
+      lines.push('');
+
+      // HTML body
+      lines.push(`--${relatedBoundary}`);
+      lines.push(`Content-Type: ${isHtml ? 'text/html' : 'text/plain'}; charset=utf-8`);
+      lines.push('');
+      lines.push(body);
+
+      // Inline images
+      for (const attachment of inlineAttachments) {
+        const encoded = await this.encodeAttachment(attachment);
+        lines.push(`--${relatedBoundary}`);
+        lines.push(`Content-Type: ${encoded.mimeType}; name="${encoded.filename}"`);
+        lines.push('Content-Transfer-Encoding: base64');
+        lines.push(`Content-ID: <${attachment.contentId}>`);
+        lines.push(`Content-Disposition: inline; filename="${encoded.filename}"`);
+        lines.push('');
+        lines.push(encoded.base64);
+      }
+      lines.push(`--${relatedBoundary}--`);
+
+    } else {
+      // Only regular: multipart/mixed (original behavior)
+      lines.push(`Content-Type: multipart/mixed; boundary="${mixedBoundary}"`);
+      lines.push('');
+      lines.push(`--${mixedBoundary}`);
+      lines.push(`Content-Type: ${isHtml ? 'text/html' : 'text/plain'}; charset=utf-8`);
+      lines.push('');
+      lines.push(body);
+
+      for (const attachment of regularAttachments) {
+        const encoded = await this.encodeAttachment(attachment);
+        lines.push(`--${mixedBoundary}`);
+        lines.push(`Content-Type: ${encoded.mimeType}; name="${encoded.filename}"`);
+        lines.push('Content-Transfer-Encoding: base64');
+        lines.push(`Content-Disposition: attachment; filename="${encoded.filename}"`);
+        lines.push('');
+        lines.push(encoded.base64);
       }
+      lines.push(`--${mixedBoundary}--`);
     }
 
-    headers.push(`--${boundary}--`);
+    return lines.join('\r\n');
+  }
+
+  private async encodeAttachment(attachment: GmailAttachment): Promise<{
+    filename: string;
+    mimeType: string;
+    base64: string;
+  }> {
+    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 filename = attachment.filename || basename(attachment.path);
+      const mimeType = attachment.mimeType || getMimeType(filename);
 
-    return headers.join('\r\n');
+      return {
+        filename,
+        mimeType,
+        base64: Buffer.from(content).toString('base64'),
+      };
+    } catch (error: any) {
+      if (error instanceof CliError) throw error;
+      throw new CliError('API_ERROR', `Failed to read attachment ${attachment.path}: ${error.message}`);
+    }
   }
 
   async reply(options: GmailReplyOptions): Promise<{ id: string; threadId: string; labelIds: string[] }> {

package/src/services/jira/client.ts

@@ -1,4 +1,5 @@
 import { CliError, type ErrorCode } from '../../utils/errors';
+import type { ServiceClient, ValidationResult } from '../../types/service';
 import type {
   JiraCredentials,
   JiraProject,
@@ -11,7 +12,7 @@ import type {
   JiraTransitionResult,
 } from '../../types/jira';
 
-export class JiraClient {
+export class JiraClient implements ServiceClient {
   private credentials: JiraCredentials;
   private baseUrl: string;
 
@@ -20,6 +21,48 @@ export class JiraClient {
     this.baseUrl = `https://api.atlassian.com/ex/jira/${credentials.cloudId}/rest/api/3`;
   }
 
+  async validate(): Promise<ValidationResult> {
+    try {
+      // Try /myself endpoint first (requires read:me scope)
+      const url = `${this.baseUrl}/myself`;
+      const response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${this.credentials.accessToken}`,
+          Accept: 'application/json',
+        },
+      });
+
+      if (response.ok) {
+        const user = await response.json() as { displayName?: string; emailAddress?: string };
+        const info = user.displayName || user.emailAddress || this.credentials.siteUrl;
+        return { valid: true, info };
+      }
+
+      // Fall back to project search if /myself fails (older tokens without read:me scope)
+      const fallbackUrl = `${this.baseUrl}/project/search?maxResults=1`;
+      const fallbackResponse = await fetch(fallbackUrl, {
+        headers: {
+          Authorization: `Bearer ${this.credentials.accessToken}`,
+          Accept: 'application/json',
+        },
+      });
+
+      if (fallbackResponse.ok) {
+        return { valid: true, info: this.credentials.siteUrl };
+      }
+
+      return {
+        valid: false,
+        error: `API returned ${fallbackResponse.status}`,
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
   private async request<T>(
     method: string,
     path: string,

package/src/services/slack/client.ts

@@ -1,4 +1,5 @@
 import { CliError } from '../../utils/errors';
+import type { ServiceClient, ValidationResult } from '../../types/service';
 import type {
   SlackCredentials,
   SlackSendOptions,
@@ -6,13 +7,20 @@ import type {
   SlackWebhookCredentials,
 } from '../../types/slack';
 
-export class SlackClient {
+export class SlackClient implements ServiceClient {
   private credentials: SlackCredentials;
 
   constructor(credentials: SlackCredentials) {
     this.credentials = credentials;
   }
 
+  async validate(): Promise<ValidationResult> {
+    // Webhooks cannot be validated without sending a message
+    const webhookCreds = this.credentials as SlackWebhookCredentials;
+    const info = webhookCreds.channelName ? `#${webhookCreds.channelName}` : 'webhook (not testable)';
+    return { valid: true, info };
+  }
+
   async send(options: SlackSendOptions): Promise<SlackSendResult> {
     if (this.credentials.type === 'webhook') {
       return this.sendViaWebhook(options);

package/src/services/telegram/client.ts

@@ -1,4 +1,5 @@
 import type { TelegramBotInfo, TelegramChat, TelegramMessage, TelegramSendOptions } from '../../types/telegram';
+import type { ServiceClient, ValidationResult } from '../../types/service';
 import { CliError } from '../../utils/errors';
 
 const TELEGRAM_API_BASE = 'https://api.telegram.org/bot';
@@ -10,7 +11,7 @@ interface TelegramApiResponse<T> {
   error_code?: number;
 }
 
-export class TelegramClient {
+export class TelegramClient implements ServiceClient {
   private baseUrl: string;
 
   constructor(
@@ -20,6 +21,18 @@ export class TelegramClient {
     this.baseUrl = `${TELEGRAM_API_BASE}${botToken}`;
   }
 
+  async validate(): Promise<ValidationResult> {
+    try {
+      const botInfo = await this.getMe();
+      return { valid: true, info: `@${botInfo.username}` };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
   private async request<T>(method: string, params?: Record<string, unknown>): Promise<T> {
     const url = `${this.baseUrl}/${method}`;
 

package/src/types/config.ts

@@ -5,6 +5,7 @@ export interface Config {
     jira?: string[];
     slack?: string[];
     telegram?: string[];
+    discourse?: string[];
   };
   defaults: {
     gmail?: string;
@@ -12,7 +13,8 @@ export interface Config {
     jira?: string;
     slack?: string;
     telegram?: string;
+    discourse?: string;
   };
 }
 
-export type ServiceName = 'gmail' | 'gchat' | 'jira' | 'slack' | 'telegram';
+export type ServiceName = 'gmail' | 'gchat' | 'jira' | 'slack' | 'telegram' | 'discourse';

package/src/types/discourse.ts

@@ -0,0 +1,62 @@
+export interface DiscourseCredentials {
+  baseUrl: string;
+  apiKey: string;
+  username: string;
+}
+
+export interface DiscourseCategory {
+  id: number;
+  name: string;
+  slug: string;
+  description: string;
+  topicCount: number;
+  postCount: number;
+  color: string;
+  parentCategoryId?: number;
+}
+
+export interface DiscoursePoster {
+  userId: number;
+  username?: string;
+}
+
+export interface DiscourseTopic {
+  id: number;
+  title: string;
+  slug: string;
+  postsCount: number;
+  replyCount: number;
+  views: number;
+  likeCount: number;
+  categoryId: number;
+  categoryName?: string;
+  createdAt: string;
+  lastPostedAt: string;
+  pinned: boolean;
+  closed: boolean;
+  archived: boolean;
+  posters?: DiscoursePoster[];
+}
+
+export interface DiscoursePost {
+  id: number;
+  username: string;
+  displayName?: string;
+  createdAt: string;
+  updatedAt: string;
+  postNumber: number;
+  raw?: string;
+  cooked: string;
+  replyCount: number;
+  likeCount: number;
+}
+
+export interface DiscourseTopicDetail extends DiscourseTopic {
+  posts: DiscoursePost[];
+}
+
+export interface DiscourseListOptions {
+  category?: string;
+  page?: number;
+  order?: 'default' | 'created' | 'activity' | 'views' | 'posts' | 'likes';
+}

package/src/types/gmail.ts

@@ -22,6 +22,7 @@ export interface GmailAttachment {
   filename: string;
   path: string;
   mimeType?: string;
+  contentId?: string;  // For inline images, referenced as cid:contentId in HTML
 }
 
 export interface GmailAttachmentInfo {

package/src/types/service.ts

@@ -0,0 +1,21 @@
+/**
+ * Result of validating service credentials.
+ */
+export interface ValidationResult {
+  valid: boolean;
+  info?: string;
+  error?: string;
+}
+
+/**
+ * Common interface for all service clients.
+ * Implementations should handle token refresh internally if needed.
+ */
+export interface ServiceClient {
+  /**
+   * Validate credentials by making an API call.
+   * Should refresh tokens internally if needed before validating.
+   * @returns ValidationResult with status and optional info/error
+   */
+  validate(): Promise<ValidationResult>;
+}

package/src/utils/output.ts

@@ -3,6 +3,7 @@ import type { GChatMessage } from '../types/gchat';
 import type { JiraProject, JiraIssue, JiraTransition, JiraCommentResult, JiraTransitionResult } from '../types/jira';
 import type { SlackSendResult } from '../types/slack';
 import type { RssFeed, RssArticle } from '../types/rss';
+import type { DiscourseCategory, DiscourseTopic, DiscourseTopicDetail } from '../types/discourse';
 
 function formatBytes(bytes: number): string {
   if (bytes === 0) return '0 B';
@@ -278,3 +279,78 @@ export function printRssFeedInfo(feed: RssFeed & { feedUrl: string }): void {
   if (feed.lastBuildDate) console.log(`Last Updated: ${feed.lastBuildDate}`);
   console.log(`Articles: ${feed.items.length}`);
 }
+
+// Discourse specific formatters
+export function printDiscourseCategoryList(categories: DiscourseCategory[]): void {
+  if (categories.length === 0) {
+    console.log('No categories found');
+    return;
+  }
+
+  console.log(`Categories (${categories.length})\n`);
+
+  for (const cat of categories) {
+    const parentInfo = cat.parentCategoryId ? ' (subcategory)' : '';
+    console.log(`[${cat.id}] ${cat.name}${parentInfo}`);
+    console.log(`    Slug: ${cat.slug}`);
+    console.log(`    Topics: ${cat.topicCount} | Posts: ${cat.postCount}`);
+    if (cat.description) {
+      const desc = cat.description.replace(/<[^>]*>/g, '').substring(0, 100);
+      if (desc) console.log(`    > ${desc}${cat.description.length > 100 ? '...' : ''}`);
+    }
+    console.log('');
+  }
+}
+
+export function printDiscourseTopicList(topics: DiscourseTopic[]): void {
+  if (topics.length === 0) {
+    console.log('No topics found');
+    return;
+  }
+
+  console.log(`Topics (${topics.length})\n`);
+
+  for (let i = 0; i < topics.length; i++) {
+    const topic = topics[i];
+    const flags: string[] = [];
+    if (topic.pinned) flags.push('pinned');
+    if (topic.closed) flags.push('closed');
+    if (topic.archived) flags.push('archived');
+    const flagStr = flags.length > 0 ? ` [${flags.join(', ')}]` : '';
+
+    console.log(`[${i + 1}] ${topic.id} | ${topic.title}${flagStr}`);
+    if (topic.categoryName) console.log(`    Category: ${topic.categoryName}`);
+    console.log(`    Posts: ${topic.postsCount} | Replies: ${topic.replyCount} | Views: ${topic.views} | Likes: ${topic.likeCount}`);
+    console.log(`    Created: ${topic.createdAt}`);
+    if (topic.lastPostedAt !== topic.createdAt) {
+      console.log(`    Last Post: ${topic.lastPostedAt}`);
+    }
+    console.log('');
+  }
+}
+
+export function printDiscourseTopic(topic: DiscourseTopicDetail): void {
+  const flags: string[] = [];
+  if (topic.pinned) flags.push('pinned');
+  if (topic.closed) flags.push('closed');
+  if (topic.archived) flags.push('archived');
+  const flagStr = flags.length > 0 ? ` [${flags.join(', ')}]` : '';
+
+  console.log(`ID: ${topic.id}`);
+  console.log(`Title: ${topic.title}${flagStr}`);
+  console.log(`Slug: ${topic.slug}`);
+  if (topic.categoryName) console.log(`Category: ${topic.categoryName}`);
+  console.log(`Posts: ${topic.postsCount} | Replies: ${topic.replyCount} | Views: ${topic.views} | Likes: ${topic.likeCount}`);
+  console.log(`Created: ${topic.createdAt}`);
+  console.log(`Last Post: ${topic.lastPostedAt}`);
+  console.log('---');
+
+  for (const post of topic.posts) {
+    const author = post.displayName || post.username;
+    console.log(`\n[Post #${post.postNumber}] by ${author} (${post.createdAt})`);
+    console.log(`Likes: ${post.likeCount} | Replies: ${post.replyCount}`);
+    // Strip HTML from cooked content for display
+    const content = post.cooked.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+    console.log(content);
+  }
+}

package/src/utils/profile-commands.ts

@@ -0,0 +1,90 @@
+import { Command } from 'commander';
+import { listProfiles, removeProfile, setDefault } from '../config/config-manager';
+import { removeCredentials, getCredentials } from '../auth/token-store';
+import { handleError, CliError } from './errors';
+import type { ServiceName } from '../types/config';
+
+export interface ProfileCommandsOptions<T> {
+  service: ServiceName;
+  displayName: string;
+  getExtraInfo?: (credentials: T | null) => string;
+}
+
+export function createProfileCommands<T>(
+  parent: Command,
+  options: ProfileCommandsOptions<T>
+): Command {
+  const { service, displayName, getExtraInfo } = options;
+
+  const profile = parent
+    .command('profile')
+    .description(`Manage ${displayName} profiles`);
+
+  profile
+    .command('list')
+    .description(`List ${displayName} profiles`)
+    .action(async () => {
+      try {
+        const result = await listProfiles(service);
+        const { profiles, default: defaultProfile } = result[0];
+
+        if (profiles.length === 0) {
+          console.log('No profiles configured');
+        } else {
+          for (const name of profiles) {
+            const marker = name === defaultProfile ? ' (default)' : '';
+            const credentials = await getCredentials<T>(service, name);
+            const extraInfo = getExtraInfo ? getExtraInfo(credentials) : '';
+            console.log(`${name}${marker}${extraInfo}`);
+          }
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  profile
+    .command('remove')
+    .description(`Remove a ${displayName} profile`)
+    .requiredOption('--profile <name>', 'Profile name')
+    .action(async (opts) => {
+      try {
+        const profileName = opts.profile;
+
+        const removed = await removeProfile(service, profileName);
+        await removeCredentials(service, profileName);
+
+        if (removed) {
+          console.log(`Removed profile "${profileName}"`);
+        } else {
+          console.error(`Profile "${profileName}" not found`);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  profile
+    .command('default')
+    .description(`Set the default ${displayName} profile`)
+    .argument('<name>', 'Profile name to set as default')
+    .action(async (name) => {
+      try {
+        const success = await setDefault(service, name);
+
+        if (success) {
+          console.log(`Default profile set to "${name}"`);
+        } else {
+          throw new CliError(
+            'PROFILE_NOT_FOUND',
+            `Profile "${name}" not found`,
+            `Run: agentio ${service} profile list`
+          );
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  return profile;
+}