@plosson/agentio 0.1.26 → 0.1.27

package/README.md

@@ -72,6 +72,7 @@ Download from [GitHub Releases](https://github.com/plosson/agentio/releases/late
 | Google Chat | Available | `send`, `list`, `get` |
 | Slack | Available | `send` |
 | JIRA | Available | `projects`, `search`, `get`, `comment`, `transitions`, `transition` |
+| RSS | Available | `articles`, `get`, `info` |
 | Linear | Planned | - |
 
 ## Usage
@@ -177,6 +178,23 @@ agentio jira transitions PROJ-123
 agentio jira transition PROJ-123 <transition-id>
 ```
 
+### RSS
+
+```bash
+# List articles from a blog (feed URL auto-discovered)
+agentio rss articles https://simonwillison.net
+agentio rss articles https://steipete.me --limit 5
+
+# Filter by date
+agentio rss articles https://blog.fsck.com --since 2025-01-01
+
+# Get feed info (shows discovered feed URL)
+agentio rss info https://kau.sh
+
+# Get a specific article
+agentio rss get https://simonwillison.net <article-url>
+```
+
 ## Multi-Profile Support
 
 Each service supports multiple named profiles:
@@ -192,54 +210,52 @@ agentio gmail list --profile work
 
 ## Claude Code Integration
 
-agentio provides plugins for [Claude Code](https://claude.ai/download) with skills for Gmail, Telegram, and Google Chat operations.
+agentio provides plugins for [Claude Code](https://claude.ai/download) with skills for Gmail, Telegram, Google Chat, JIRA, and RSS operations.
 
-### Install the Plugin
+### Install Marketplaces and Plugins
 
 ```bash
-# Install from GitHub
-agentio claude plugin install plosson/agentio
+# Add a marketplace (auto-detected from URL)
+agentio claude install https://github.com/plosson/agentio
 
-# Or install from a full GitHub URL
-agentio claude plugin install https://github.com/plosson/agentio
+# Install a plugin (auto-detected from name@marketplace format)
+agentio claude install agentio-gmail@agentio
 
-# Install to a specific directory
-agentio claude plugin install plosson/agentio -d ~/myproject
-
-# Install only specific components (skills, commands, hooks, agents)
-agentio claude plugin install plosson/agentio --skills
-agentio claude plugin install plosson/agentio --agents
-
-# Force reinstall if already exists
-agentio claude plugin install plosson/agentio -f
-
-# Show detailed installation logs
-agentio claude plugin install plosson/agentio --verbose
+# Install all from agentio.json
+agentio claude install
 ```
 
-Once installed, Claude Code can use the agentio CLI skills to help you manage emails, send Telegram messages, and more.
-
 ### Manage Plugins
 
 ```bash
-# List installed plugins
-agentio claude plugin list
+# List marketplaces and plugins from agentio.json
+agentio claude list
 
-# Remove a plugin
-agentio claude plugin remove agentio
+# Update marketplaces
+agentio claude update
+agentio claude update https://github.com/plosson/agentio
+
+# Remove a marketplace or plugin
+agentio claude remove https://github.com/plosson/agentio
+agentio claude remove agentio-gmail@agentio
 ```
 
-### Install from agentio.json
+### agentio.json
 
-If your project has an `agentio.json` file listing plugins, you can install all of them at once:
+Projects can define marketplaces and plugins in an `agentio.json` file:
 
-```bash
-# Install all plugins from agentio.json in current directory
-agentio claude plugin install
+```json
+{
+  "marketplaces": [
+    "https://github.com/plosson/agentio"
+  ],
+  "plugins": [
+    "agentio-gmail@agentio",
+    "agentio-rss@agentio"
+  ]
+}
 ```
 
-Plugins are installed to `.claude/` in the target directory (skills, commands, hooks, and agents subdirectories).
-
 ## Design
 
 agentio is designed for LLM consumption:

package/package.json

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

package/src/commands/discourse.ts

@@ -0,0 +1,248 @@
+import { Command } from 'commander';
+import { setCredentials, removeCredentials, getCredentials } from '../auth/token-store';
+import { setProfile, removeProfile, listProfiles, getProfile } from '../config/config-manager';
+import { DiscourseClient } from '../services/discourse/client';
+import { CliError, handleError } from '../utils/errors';
+import { prompt, resolveProfileName } from '../utils/stdin';
+import type { DiscourseCredentials } from '../types/discourse';
+import {
+  printDiscourseTopicList,
+  printDiscourseTopic,
+  printDiscourseCategoryList,
+} from '../utils/output';
+
+async function getDiscourseClient(
+  profileName?: string
+): Promise<{ client: DiscourseClient; profile: string }> {
+  const profile = await getProfile('discourse', profileName);
+
+  if (!profile) {
+    throw new CliError(
+      'PROFILE_NOT_FOUND',
+      profileName
+        ? `Profile "${profileName}" not found for discourse`
+        : 'No default profile configured for discourse',
+      'Run: agentio discourse profile add'
+    );
+  }
+
+  const credentials = await getCredentials<DiscourseCredentials>('discourse', profile);
+
+  if (!credentials) {
+    throw new CliError(
+      'AUTH_FAILED',
+      `No credentials found for discourse profile "${profile}"`,
+      `Run: agentio discourse profile add --profile ${profile}`
+    );
+  }
+
+  return {
+    client: new DiscourseClient(credentials),
+    profile,
+  };
+}
+
+export function registerDiscourseCommands(program: Command): void {
+  const discourse = program.command('discourse').description('Discourse forum operations');
+
+  // List topics
+  discourse
+    .command('list')
+    .description('List latest topics')
+    .option('--profile <name>', 'Profile name')
+    .option('--category <slug>', 'Filter by category slug or name')
+    .option('--page <number>', 'Page number (0-indexed)', '0')
+    .action(async (options) => {
+      try {
+        const { client } = await getDiscourseClient(options.profile);
+        const topics = await client.listTopics({
+          category: options.category,
+          page: parseInt(options.page, 10),
+        });
+        printDiscourseTopicList(topics);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Get topic detail
+  discourse
+    .command('get')
+    .description('Get a topic with its posts')
+    .argument('<topic-id>', 'Topic ID')
+    .option('--profile <name>', 'Profile name')
+    .action(async (topicId: string, options) => {
+      try {
+        const id = parseInt(topicId, 10);
+        if (isNaN(id)) {
+          throw new CliError('INVALID_PARAMS', 'Topic ID must be a number');
+        }
+
+        const { client } = await getDiscourseClient(options.profile);
+        const topic = await client.getTopic(id);
+        printDiscourseTopic(topic);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // List categories
+  discourse
+    .command('categories')
+    .description('List all categories')
+    .option('--profile <name>', 'Profile name')
+    .action(async (options) => {
+      try {
+        const { client } = await getDiscourseClient(options.profile);
+        const categories = await client.getCategories();
+        printDiscourseCategoryList(categories);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Profile management
+  const profile = discourse.command('profile').description('Manage Discourse profiles');
+
+  profile
+    .command('add')
+    .description('Add a new Discourse profile')
+    .option('--profile <name>', 'Profile name', 'default')
+    .action(async (options) => {
+      try {
+        const profileName = await resolveProfileName('discourse', options.profile);
+
+        console.error('\n💬 Discourse Setup\n');
+
+        // Step 1: Get base URL
+        console.error('Step 1: Enter your Discourse forum URL');
+        console.error('  Example: https://meta.discourse.org or https://forum.example.com\n');
+
+        const baseUrl = await prompt('? Forum URL: ');
+
+        if (!baseUrl) {
+          throw new CliError('INVALID_PARAMS', 'Forum URL is required');
+        }
+
+        // Normalize URL
+        let normalizedUrl = baseUrl.trim();
+        if (!normalizedUrl.startsWith('http://') && !normalizedUrl.startsWith('https://')) {
+          normalizedUrl = `https://${normalizedUrl}`;
+        }
+        normalizedUrl = normalizedUrl.replace(/\/$/, '');
+
+        // Step 2: Get API credentials
+        console.error('\nStep 2: Create an API key');
+        console.error('  1. Go to your Discourse admin panel');
+        console.error(`     ${normalizedUrl}/admin/api/keys`);
+        console.error('  2. Click "New API Key"');
+        console.error('  3. Description: "agentio CLI"');
+        console.error('  4. User Level: Choose your user or "All Users" for admin access');
+        console.error('  5. Scope: "Read" (or "Read, Write" if you plan to create topics later)');
+        console.error('  6. Click "Save" and copy the API key\n');
+
+        const apiKey = await prompt('? API Key: ');
+
+        if (!apiKey) {
+          throw new CliError('INVALID_PARAMS', 'API key is required');
+        }
+
+        console.error('\nStep 3: Enter your Discourse username');
+        console.error('  This should match the user associated with the API key\n');
+
+        const username = await prompt('? Username: ');
+
+        if (!username) {
+          throw new CliError('INVALID_PARAMS', 'Username is required');
+        }
+
+        // Validate credentials
+        console.error('\nValidating credentials...');
+
+        const credentials: DiscourseCredentials = {
+          baseUrl: normalizedUrl,
+          apiKey: apiKey.trim(),
+          username: username.trim(),
+        };
+
+        const client = new DiscourseClient(credentials);
+        try {
+          await client.validateCredentials();
+        } catch (error) {
+          if (error instanceof CliError) {
+            if (error.code === 'AUTH_FAILED') {
+              throw new CliError(
+                'AUTH_FAILED',
+                'Invalid API key or username. Please check your credentials.',
+                'Make sure the API key is active and the username matches'
+              );
+            }
+            if (error.code === 'NETWORK_ERROR') {
+              throw new CliError(
+                'NETWORK_ERROR',
+                `Cannot connect to ${normalizedUrl}`,
+                'Check the URL and your network connection'
+              );
+            }
+          }
+          throw error;
+        }
+
+        console.error(`\n✓ Connected to ${normalizedUrl}`);
+        console.error(`✓ Authenticated as ${username}\n`);
+
+        // Save credentials
+        await setProfile('discourse', profileName);
+        await setCredentials('discourse', profileName, credentials);
+
+        console.log(`\n✅ Profile "${profileName}" configured!`);
+        console.log(`   Test with: agentio discourse list --profile ${profileName}`);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  profile
+    .command('list')
+    .description('List Discourse profiles')
+    .action(async () => {
+      try {
+        const result = await listProfiles('discourse');
+        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<DiscourseCredentials>('discourse', name);
+            const urlInfo = credentials?.baseUrl ? ` - ${credentials.baseUrl}` : '';
+            console.log(`${name}${marker}${urlInfo}`);
+          }
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  profile
+    .command('remove')
+    .description('Remove a Discourse profile')
+    .requiredOption('--profile <name>', 'Profile name')
+    .action(async (options) => {
+      try {
+        const profileName = options.profile;
+
+        const removed = await removeProfile('discourse', profileName);
+        await removeCredentials('discourse', profileName);
+
+        if (removed) {
+          console.error(`Removed profile "${profileName}"`);
+        } else {
+          console.error(`Profile "${profileName}" not found`);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/commands/gmail.ts

@@ -185,6 +185,7 @@ Query Syntax Examples:
     .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], [])
     .action(async (options) => {
       try {
         let body = options.body;
@@ -198,13 +199,32 @@ Query Syntax Examples:
           throw new CliError('INVALID_PARAMS', 'Body is required. Use --body or pipe via stdin.');
         }
 
-        // Process attachments
-        const attachments: GmailAttachment[] | undefined = options.attachment.length
-          ? options.attachment.map((path: string) => ({
-              path,
-              filename: basename(path),
-            }))
-          : undefined;
+        // 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 { client } = await getGmailClient(options.profile);
         const result = await client.send({

package/src/index.ts

@@ -6,6 +6,7 @@ import { registerGChatCommands } from './commands/gchat';
 import { registerJiraCommands } from './commands/jira';
 import { registerSlackCommands } from './commands/slack';
 import { registerRssCommands } from './commands/rss';
+import { registerDiscourseCommands } from './commands/discourse';
 import { registerUpdateCommand } from './commands/update';
 import { registerConfigCommands } from './commands/config';
 import { registerClaudeCommands } from './commands/claude';
@@ -33,6 +34,7 @@ registerGChatCommands(program);
 registerJiraCommands(program);
 registerSlackCommands(program);
 registerRssCommands(program);
+registerDiscourseCommands(program);
 registerUpdateCommand(program);
 registerConfigCommands(program);
 registerClaudeCommands(program);

package/src/services/discourse/client.ts

@@ -0,0 +1,273 @@
+import type {
+  DiscourseCredentials,
+  DiscourseCategory,
+  DiscourseTopic,
+  DiscourseTopicDetail,
+  DiscoursePost,
+  DiscourseListOptions,
+} from '../../types/discourse';
+import { CliError, type ErrorCode } from '../../utils/errors';
+
+interface DiscourseApiResponse {
+  errors?: string[];
+  error_type?: string;
+}
+
+interface CategoryListResponse extends DiscourseApiResponse {
+  category_list: {
+    categories: RawCategory[];
+  };
+}
+
+interface RawCategory {
+  id: number;
+  name: string;
+  slug: string;
+  description: string;
+  topic_count: number;
+  post_count: number;
+  color: string;
+  parent_category_id?: number;
+}
+
+interface TopicListResponse extends DiscourseApiResponse {
+  topic_list: {
+    topics: RawTopic[];
+  };
+}
+
+interface RawTopic {
+  id: number;
+  title: string;
+  slug: string;
+  posts_count: number;
+  reply_count: number;
+  views: number;
+  like_count: number;
+  category_id: number;
+  created_at: string;
+  last_posted_at: string;
+  pinned: boolean;
+  closed: boolean;
+  archived: boolean;
+  posters?: Array<{ user_id: number; extras?: string }>;
+}
+
+interface TopicDetailResponse extends DiscourseApiResponse {
+  id: number;
+  title: string;
+  slug: string;
+  posts_count: number;
+  reply_count: number;
+  views: number;
+  like_count: number;
+  category_id: number;
+  created_at: string;
+  last_posted_at: string;
+  pinned: boolean;
+  closed: boolean;
+  archived: boolean;
+  post_stream: {
+    posts: RawPost[];
+  };
+}
+
+interface RawPost {
+  id: number;
+  username: string;
+  display_username?: string;
+  created_at: string;
+  updated_at: string;
+  post_number: number;
+  raw?: string;
+  cooked: string;
+  reply_count: number;
+  like_count: number;
+}
+
+export class DiscourseClient {
+  private baseUrl: string;
+  private apiKey: string;
+  private username: string;
+  private categoryCache: Map<number, string> = new Map();
+
+  constructor(credentials: DiscourseCredentials) {
+    this.baseUrl = credentials.baseUrl.replace(/\/$/, '');
+    this.apiKey = credentials.apiKey;
+    this.username = credentials.username;
+  }
+
+  private async request<T>(
+    method: string,
+    path: string,
+    body?: Record<string, unknown>
+  ): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+          'Api-Key': this.apiKey,
+          'Api-Username': this.username,
+        },
+        body: body ? JSON.stringify(body) : undefined,
+      });
+
+      if (!response.ok) {
+        const errorCode = this.getErrorCode(response.status);
+        const text = await response.text();
+        let message = `Discourse API error: ${response.status}`;
+        try {
+          const data = JSON.parse(text) as DiscourseApiResponse;
+          if (data.errors) {
+            message = data.errors.join(', ');
+          }
+        } catch {
+          if (text) message = text;
+        }
+        throw new CliError(errorCode, message);
+      }
+
+      return (await response.json()) as T;
+    } 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 Discourse: ${message}`);
+    }
+  }
+
+  private getErrorCode(status: number): ErrorCode {
+    if (status === 401 || status === 403) return 'AUTH_FAILED';
+    if (status === 404) return 'NOT_FOUND';
+    if (status === 429) return 'RATE_LIMITED';
+    return 'API_ERROR';
+  }
+
+  async getCategories(): Promise<DiscourseCategory[]> {
+    const data = await this.request<CategoryListResponse>('GET', '/categories.json');
+
+    const categories = data.category_list.categories.map((cat) => this.parseCategory(cat));
+
+    // Cache category names for topic listings
+    for (const cat of categories) {
+      this.categoryCache.set(cat.id, cat.name);
+    }
+
+    return categories;
+  }
+
+  private parseCategory(raw: RawCategory): DiscourseCategory {
+    return {
+      id: raw.id,
+      name: raw.name,
+      slug: raw.slug,
+      description: raw.description || '',
+      topicCount: raw.topic_count,
+      postCount: raw.post_count,
+      color: raw.color,
+      parentCategoryId: raw.parent_category_id,
+    };
+  }
+
+  async listTopics(options?: DiscourseListOptions): Promise<DiscourseTopic[]> {
+    let path: string;
+
+    if (options?.category) {
+      // Need to find category by slug
+      const categories = await this.getCategories();
+      const category = categories.find(
+        (c) => c.slug === options.category || c.name.toLowerCase() === options.category?.toLowerCase()
+      );
+      if (!category) {
+        throw new CliError('NOT_FOUND', `Category "${options.category}" not found`);
+      }
+      path = `/c/${category.slug}/${category.id}/l/latest.json`;
+    } else {
+      path = '/latest.json';
+    }
+
+    if (options?.page && options.page > 0) {
+      path += `?page=${options.page}`;
+    }
+
+    const data = await this.request<TopicListResponse>('GET', path);
+
+    // Ensure category cache is populated
+    if (this.categoryCache.size === 0) {
+      await this.getCategories();
+    }
+
+    return data.topic_list.topics.map((topic) => this.parseTopic(topic));
+  }
+
+  private parseTopic(raw: RawTopic): DiscourseTopic {
+    return {
+      id: raw.id,
+      title: raw.title,
+      slug: raw.slug,
+      postsCount: raw.posts_count,
+      replyCount: raw.reply_count,
+      views: raw.views,
+      likeCount: raw.like_count,
+      categoryId: raw.category_id,
+      categoryName: this.categoryCache.get(raw.category_id),
+      createdAt: raw.created_at,
+      lastPostedAt: raw.last_posted_at,
+      pinned: raw.pinned,
+      closed: raw.closed,
+      archived: raw.archived,
+      posters: raw.posters?.map((p) => ({ userId: p.user_id })),
+    };
+  }
+
+  async getTopic(topicId: number): Promise<DiscourseTopicDetail> {
+    const data = await this.request<TopicDetailResponse>('GET', `/t/${topicId}.json`);
+
+    // Ensure category cache is populated
+    if (this.categoryCache.size === 0) {
+      await this.getCategories();
+    }
+
+    return {
+      id: data.id,
+      title: data.title,
+      slug: data.slug,
+      postsCount: data.posts_count,
+      replyCount: data.reply_count,
+      views: data.views,
+      likeCount: data.like_count,
+      categoryId: data.category_id,
+      categoryName: this.categoryCache.get(data.category_id),
+      createdAt: data.created_at,
+      lastPostedAt: data.last_posted_at,
+      pinned: data.pinned,
+      closed: data.closed,
+      archived: data.archived,
+      posts: data.post_stream.posts.map((p) => this.parsePost(p)),
+    };
+  }
+
+  private parsePost(raw: RawPost): DiscoursePost {
+    return {
+      id: raw.id,
+      username: raw.username,
+      displayName: raw.display_username,
+      createdAt: raw.created_at,
+      updatedAt: raw.updated_at,
+      postNumber: raw.post_number,
+      raw: raw.raw,
+      cooked: raw.cooked,
+      replyCount: raw.reply_count,
+      likeCount: raw.like_count,
+    };
+  }
+
+  async validateCredentials(): Promise<{ username: string }> {
+    // Try to fetch categories as a validation check
+    await this.getCategories();
+    return { username: this.username };
+  }
+}

package/src/services/gmail/client.ts

@@ -308,54 +308,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}`);
+      }
 
-    return headers.join('\r\n');
+      const content = await file.arrayBuffer();
+      const filename = attachment.filename || basename(attachment.path);
+      const mimeType = attachment.mimeType || getMimeType(filename);
+
+      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/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/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);
+  }
+}