@plosson/agentio 0.1.26 → 0.1.28

package/src/commands/status.ts

@@ -0,0 +1,164 @@
+import { Command } from 'commander';
+import { listProfiles, CONFIG_DIR } from '../config/config-manager';
+import { getCredentials, setCredentials } from '../auth/token-store';
+import { createGoogleAuth } from '../auth/token-manager';
+import { refreshJiraToken } from '../auth/jira-oauth';
+import { TelegramClient } from '../services/telegram/client';
+import { GmailClient } from '../services/gmail/client';
+import { JiraClient } from '../services/jira/client';
+import { GChatClient } from '../services/gchat/client';
+import { SlackClient } from '../services/slack/client';
+import { DiscourseClient } from '../services/discourse/client';
+import type { ServiceClient, ValidationResult } from '../types/service';
+import type { ServiceName } from '../types/config';
+import type { OAuthTokens } from '../types/tokens';
+import type { TelegramCredentials } from '../types/telegram';
+import type { JiraCredentials } from '../types/jira';
+import type { GChatCredentials } from '../types/gchat';
+import type { SlackCredentials } from '../types/slack';
+import type { DiscourseCredentials } from '../types/discourse';
+
+type GmailCredentials = OAuthTokens & { email?: string };
+
+/**
+ * Creates a ServiceClient for the given service and credentials.
+ * Handles token refresh for OAuth services before creating the client.
+ */
+async function createServiceClient(
+  service: ServiceName,
+  credentials: unknown,
+  profileName: string
+): Promise<ServiceClient | null> {
+  switch (service) {
+    case 'gmail': {
+      const creds = credentials as GmailCredentials;
+      const auth = createGoogleAuth({
+        access_token: creds.access_token,
+        refresh_token: creds.refresh_token,
+        expiry_date: creds.expiry_date,
+        token_type: creds.token_type || 'Bearer',
+        scope: creds.scope,
+      });
+      return new GmailClient(auth);
+    }
+
+    case 'telegram': {
+      const creds = credentials as TelegramCredentials;
+      return new TelegramClient(creds.bot_token, creds.channel_id);
+    }
+
+    case 'jira': {
+      let creds = credentials as JiraCredentials;
+      // Refresh token if expired or about to expire
+      const bufferTime = 5 * 60 * 1000;
+      if (creds.expiryDate && Date.now() + bufferTime >= creds.expiryDate) {
+        try {
+          const refreshed = await refreshJiraToken(creds.refreshToken);
+          creds = {
+            ...creds,
+            accessToken: refreshed.accessToken,
+            refreshToken: refreshed.refreshToken,
+            expiryDate: Date.now() + refreshed.expiresIn * 1000,
+          };
+          await setCredentials('jira', profileName, creds);
+        } catch {
+          // Return a mock client that reports refresh failure
+          return {
+            validate: async () => ({
+              valid: false,
+              error: 'refresh token expired, re-authenticate',
+            }),
+          };
+        }
+      }
+      return new JiraClient(creds);
+    }
+
+    case 'gchat': {
+      const creds = credentials as GChatCredentials;
+      return new GChatClient(creds);
+    }
+
+    case 'slack': {
+      const creds = credentials as SlackCredentials;
+      return new SlackClient(creds);
+    }
+
+    case 'discourse': {
+      const creds = credentials as DiscourseCredentials;
+      return new DiscourseClient(creds);
+    }
+
+    default:
+      return null;
+  }
+}
+
+export function registerStatusCommand(program: Command): void {
+  program
+    .command('status')
+    .description('Show configured profiles and credential status')
+    .option('--no-test', 'Skip credential testing')
+    .action(async (options) => {
+      try {
+        const allProfiles = await listProfiles();
+        const version = program.version();
+
+        console.log(`agentio v${version}`);
+        console.log(`Config: ${CONFIG_DIR}\n`);
+
+        let hasProfiles = false;
+
+        for (const { service, profiles, default: defaultProfile } of allProfiles) {
+          if (profiles.length === 0) {
+            continue;
+          }
+
+          hasProfiles = true;
+          const displayName = service.charAt(0).toUpperCase() + service.slice(1);
+          console.log(displayName);
+
+          for (const name of profiles) {
+            const marker = name === defaultProfile ? ' (default)' : '';
+            const credentials = await getCredentials(service, name);
+
+            if (!credentials) {
+              console.log(`  ${name}${marker}    ? no credentials`);
+              continue;
+            }
+
+            if (options.test === false) {
+              console.log(`  ${name}${marker}`);
+              continue;
+            }
+
+            const client = await createServiceClient(service, credentials, name);
+            let result: ValidationResult;
+
+            if (client) {
+              result = await client.validate();
+            } else {
+              result = { valid: true, info: 'unknown service' };
+            }
+
+            const status = result.valid ? 'ok' : 'invalid';
+            const statusMark = result.valid ? '+' : 'x';
+            const info = result.info ? `  ${result.info}` : '';
+            const error = result.error ? `  (${result.error})` : '';
+
+            console.log(`  ${name}${marker}    ${statusMark} ${status}${info}${error}`);
+          }
+
+          console.log();
+        }
+
+        if (!hasProfiles) {
+          console.log('No profiles configured.');
+          console.log('Run: agentio <service> profile add');
+        }
+      } catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+      }
+    });
+}

package/src/commands/telegram.ts

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
-import { setCredentials, removeCredentials, getCredentials } from '../auth/token-store';
-import { setProfile, removeProfile, listProfiles, getProfile } from '../config/config-manager';
+import { setCredentials, getCredentials } from '../auth/token-store';
+import { setProfile, getProfile } from '../config/config-manager';
+import { createProfileCommands } from '../utils/profile-commands';
 import { TelegramClient } from '../services/telegram/client';
 import { CliError, handleError } from '../utils/errors';
 import { readStdin, prompt, resolveProfileName } from '../utils/stdin';
@@ -82,9 +83,11 @@ export function registerTelegramCommands(program: Command): void {
     });
 
   // Profile management
-  const profile = telegram
-    .command('profile')
-    .description('Manage Telegram profiles');
+  const profile = createProfileCommands<TelegramCredentials>(telegram, {
+    service: 'telegram',
+    displayName: 'Telegram',
+    getExtraInfo: (credentials) => credentials?.channel_name ? ` - ${credentials.channel_name}` : '',
+  });
 
   profile
     .command('add')
@@ -94,16 +97,16 @@ export function registerTelegramCommands(program: Command): void {
       try {
         const profileName = await resolveProfileName('telegram', options.profile);
 
-        console.error('\n📱 Telegram Bot Setup\n');
+        console.error('\nTelegram Bot Setup\n');
 
         // Step 1: Create bot
         console.error('Step 1: Create your bot');
         console.error('  Open Telegram and message @BotFather');
-        console.error('  → https://t.me/BotFather\n');
+        console.error('  -> https://t.me/BotFather\n');
         console.error('  Send these commands:');
         console.error('    /newbot');
-        console.error('    → Enter a display name (e.g., "My Announcements Bot")');
-        console.error('    → Enter a username ending in "bot" (e.g., "my_announce_bot")\n');
+        console.error('    -> Enter a display name (e.g., "My Announcements Bot")');
+        console.error('    -> Enter a username ending in "bot" (e.g., "my_announce_bot")\n');
         console.error('  BotFather will give you a token like:');
         console.error('    123456789:ABCdefGHIjklMNOpqrsTUVwxyz\n');
 
@@ -125,17 +128,17 @@ export function registerTelegramCommands(program: Command): void {
           throw error;
         }
 
-        console.error(`\n✓ Bot verified: @${botInfo.username}\n`);
+        console.error(`\nBot verified: @${botInfo.username}\n`);
 
         // Step 2: Add bot to channel
         console.error('Step 2: Add bot to your channel');
         console.error('  1. Open your Telegram channel');
-        console.error('  2. Go to Channel Settings → Administrators');
+        console.error('  2. Go to Channel Settings -> Administrators');
         console.error(`  3. Add @${botInfo.username} as admin with "Post Messages" permission\n`);
 
         console.error('  How to find your channel ID:');
-        console.error('  • Public channel: Use @username (e.g., @mychannel)');
-        console.error('  • Private channel: Forward any message from the channel to @userinfobot');
+        console.error('  - Public channel: Use @username (e.g., @mychannel)');
+        console.error('  - Private channel: Forward any message from the channel to @userinfobot');
         console.error('    The bot will reply with the channel ID (starts with -100)\n');
 
         const channelId = await prompt('? Enter channel ID: ');
@@ -162,8 +165,8 @@ export function registerTelegramCommands(program: Command): void {
         }
 
         const channelName = chatInfo.title || chatInfo.username || channelId;
-        console.error(`\n✓ Channel verified: ${channelName}`);
-        console.error('✓ Bot can post to this channel\n');
+        console.error(`\nChannel verified: ${channelName}`);
+        console.error('Bot can post to this channel\n');
 
         // Step 3: Optional customization tips
         console.error('Step 3: Customize your bot (optional)');
@@ -182,54 +185,10 @@ export function registerTelegramCommands(program: Command): void {
         await setProfile('telegram', profileName);
         await setCredentials('telegram', profileName, credentials);
 
-        console.log(`\n✅ Profile "${profileName}" configured!`);
+        console.log(`\nProfile "${profileName}" configured!`);
         console.log(`   Test with: agentio telegram send --profile ${profileName} "Hello world"`);
       } catch (error) {
         handleError(error);
       }
     });
-
-  profile
-    .command('list')
-    .description('List Telegram profiles')
-    .action(async () => {
-      try {
-        const result = await listProfiles('telegram');
-        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<TelegramCredentials>('telegram', name);
-            const channelInfo = credentials?.channel_name ? ` - ${credentials.channel_name}` : '';
-            console.log(`${name}${marker}${channelInfo}`);
-          }
-        }
-      } catch (error) {
-        handleError(error);
-      }
-    });
-
-  profile
-    .command('remove')
-    .description('Remove a Telegram profile')
-    .requiredOption('--profile <name>', 'Profile name')
-    .action(async (options) => {
-      try {
-        const profileName = options.profile;
-
-        const removed = await removeProfile('telegram', profileName);
-        await removeCredentials('telegram', profileName);
-
-        if (removed) {
-          console.error(`Removed profile "${profileName}"`);
-        } else {
-          console.error(`Profile "${profileName}" not found`);
-        }
-      } catch (error) {
-        handleError(error);
-      }
-    });
 }

package/src/config/config-manager.ts

@@ -109,13 +109,29 @@ export async function removeProfile(
   return true;
 }
 
+export async function setDefault(
+  service: ServiceName,
+  profileName: string
+): Promise<boolean> {
+  const config = await loadConfig();
+
+  const serviceProfiles = config.profiles[service] || [];
+  if (!serviceProfiles.includes(profileName)) {
+    return false;
+  }
+
+  config.defaults[service] = profileName;
+  await saveConfig(config);
+  return true;
+}
+
 export async function listProfiles(service?: ServiceName): Promise<{
   service: ServiceName;
   profiles: string[];
   default?: string;
 }[]> {
   const config = await loadConfig();
-  const services: ServiceName[] = service ? [service] : ['gmail', 'gchat', 'jira', 'slack', 'telegram'];
+  const services: ServiceName[] = service ? [service] : ['gmail', 'gchat', 'jira', 'slack', 'telegram', 'discourse'];
 
   return services.map((svc) => ({
     service: svc,

package/src/config/credentials.ts

@@ -13,8 +13,8 @@ export const GOOGLE_OAUTH_CONFIG = {
 };
 
 // JIRA/Atlassian OAuth credentials
-const JIRA_CLIENT_ID = '7408S0MZKdYnsiz0KXlUT15Lb69k7y0e';
-const JIRA_CLIENT_SECRET_ENC = 'C0J5Cyvhfl_UHCvmY9BfvKa_gzqdaa5mb3FwzRmq-YApJdAoBAKmeCl3xmcYLRCFdMvQLWVmifTkryoB0bmhVWX6eRTzoj1q4iyyTxZzT0yff0pYvLguHzp9Y4U';
+const JIRA_CLIENT_ID = 'cVyhx1kQLRUef6gr50M9cTDke7ZPL4CN';
+const JIRA_CLIENT_SECRET_ENC = 'cFN1vM5KVVVCIkv9YlE5O0rerKJUkr-CszeusEVxofAH7W0evcCidzAB_OdTygfAcq2LjbN1IXK7ZiBBl3XrBsIO7RfxSGcEfHWpSbbHWxnKPP6H2iOoQZbOfns';
 
 export const JIRA_OAUTH_CONFIG = {
   clientId: JIRA_CLIENT_ID,

package/src/index.ts

@@ -6,9 +6,11 @@ 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';
+import { registerStatusCommand } from './commands/status';
 
 declare const BUILD_VERSION: string | undefined;
 
@@ -33,8 +35,10 @@ registerGChatCommands(program);
 registerJiraCommands(program);
 registerSlackCommands(program);
 registerRssCommands(program);
+registerDiscourseCommands(program);
 registerUpdateCommand(program);
 registerConfigCommands(program);
 registerClaudeCommands(program);
+registerStatusCommand(program);
 
 program.parse();

package/src/services/discourse/client.ts

@@ -0,0 +1,287 @@
+import type {
+  DiscourseCredentials,
+  DiscourseCategory,
+  DiscourseTopic,
+  DiscourseTopicDetail,
+  DiscoursePost,
+  DiscourseListOptions,
+} from '../../types/discourse';
+import type { ServiceClient, ValidationResult } from '../../types/service';
+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 implements ServiceClient {
+  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;
+  }
+
+  async validate(): Promise<ValidationResult> {
+    try {
+      await this.getCategories();
+      return { valid: true, info: this.baseUrl };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  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) return 'AUTH_FAILED';
+    if (status === 403) return 'PERMISSION_DENIED';
+    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/gchat/client.ts

@@ -2,6 +2,7 @@ import { google } from 'googleapis';
 import type { chat_v1 } from 'googleapis';
 import { CliError } from '../../utils/errors';
 import type { ErrorCode } from '../../utils/errors';
+import type { ServiceClient, ValidationResult } from '../../types/service';
 import { GOOGLE_OAUTH_CONFIG } from '../../config/credentials';
 import type {
   GChatCredentials,
@@ -14,13 +15,34 @@ import type {
   GChatMessage,
 } from '../../types/gchat';
 
-export class GChatClient {
+export class GChatClient implements ServiceClient {
   private credentials: GChatCredentials;
 
   constructor(credentials: GChatCredentials) {
     this.credentials = credentials;
   }
 
+  async validate(): Promise<ValidationResult> {
+    if (this.credentials.type === 'webhook') {
+      // Cannot validate webhooks without sending a message
+      return { valid: true, info: 'webhook (not testable)' };
+    }
+
+    try {
+      const oauthCreds = this.credentials as GChatOAuthCredentials;
+      const auth = this.createOAuthClient(oauthCreds);
+      const chat = google.chat({ version: 'v1', auth });
+      await chat.spaces.list({ pageSize: 1 });
+      return { valid: true, info: 'oauth' };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      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 };
+    }
+  }
+
   async send(options: GChatSendOptions & { spaceId?: string }): Promise<GChatSendResult> {
     if (this.credentials.type === 'webhook') {
       return this.sendViaWebhook(options);