@plosson/agentio 0.1.27 → 0.1.29

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

@@ -10,6 +10,7 @@ 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;
 
@@ -38,5 +39,6 @@ registerDiscourseCommands(program);
 registerUpdateCommand(program);
 registerConfigCommands(program);
 registerClaudeCommands(program);
+registerStatusCommand(program);
 
 program.parse();

package/src/services/discourse/client.ts

@@ -6,6 +6,7 @@ import type {
   DiscoursePost,
   DiscourseListOptions,
 } from '../../types/discourse';
+import type { ServiceClient, ValidationResult } from '../../types/service';
 import { CliError, type ErrorCode } from '../../utils/errors';
 
 interface DiscourseApiResponse {
@@ -85,7 +86,7 @@ interface RawPost {
   like_count: number;
 }
 
-export class DiscourseClient {
+export class DiscourseClient implements ServiceClient {
   private baseUrl: string;
   private apiKey: string;
   private username: string;
@@ -97,6 +98,18 @@ export class DiscourseClient {
     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,
@@ -140,7 +153,8 @@ export class DiscourseClient {
   }
 
   private getErrorCode(status: number): ErrorCode {
-    if (status === 401 || status === 403) return 'AUTH_FAILED';
+    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';

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' };
+    }
+
+    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);

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;
 

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';
+    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/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/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;
+}