@plosson/agentio 0.3.0 → 0.3.2

package/src/commands/config.ts

@@ -6,6 +6,7 @@ import { join } from 'path';
 import { loadConfig, saveConfig, setEnv, unsetEnv, listEnv } from '../config/config-manager';
 import { getAllCredentials, setAllCredentials } from '../auth/token-store';
 import { CliError, handleError } from '../utils/errors';
+import { confirm } from '../utils/stdin';
 import type { Config } from '../types/config';
 import type { StoredCredentials } from '../types/tokens';
 
@@ -308,4 +309,32 @@ export function registerConfigCommands(program: Command): void {
         handleError(error);
       }
     });
+
+  config
+    .command('clear')
+    .description('Clear all configuration and credentials')
+    .option('--force', 'Skip confirmation prompt')
+    .action(async (options) => {
+      try {
+        if (!options.force) {
+          const confirmed = await confirm(
+            'This will delete all profiles and credentials. Are you sure?'
+          );
+          if (!confirmed) {
+            console.error('Aborted');
+            return;
+          }
+        }
+
+        // Reset config to default (empty profiles)
+        await saveConfig({ profiles: {} });
+
+        // Clear all credentials
+        await setAllCredentials({});
+
+        console.log('Configuration cleared');
+      } catch (error) {
+        handleError(error);
+      }
+    });
 }

package/src/commands/discourse.ts

@@ -1,7 +1,8 @@
 import { Command } from 'commander';
-import { setCredentials, getCredentials } from '../auth/token-store';
-import { setProfile, getProfile } from '../config/config-manager';
+import { setCredentials } from '../auth/token-store';
+import { setProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
+import { createClientGetter } from '../utils/client-factory';
 import { DiscourseClient } from '../services/discourse/client';
 import { CliError, handleError } from '../utils/errors';
 import { prompt } from '../utils/stdin';
@@ -12,34 +13,10 @@ import {
   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',
-      `Profile "${profileName}" not found 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,
-  };
-}
+const getDiscourseClient = createClientGetter<DiscourseCredentials, DiscourseClient>({
+  service: 'discourse',
+  createClient: (credentials) => new DiscourseClient(credentials),
+});
 
 export function registerDiscourseCommands(program: Command): void {
   const discourse = program.command('discourse').description('Discourse forum operations');

package/src/commands/gchat.ts

@@ -1,9 +1,10 @@
 import { Command } from 'commander';
 import { google } from 'googleapis';
 import { readFile } from 'fs/promises';
-import { setCredentials, getCredentials } from '../auth/token-store';
-import { setProfile, getProfile } from '../config/config-manager';
+import { setCredentials } from '../auth/token-store';
+import { setProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
+import { createClientGetter } from '../utils/client-factory';
 import { performOAuthFlow } from '../auth/oauth';
 import { createGoogleAuth } from '../auth/token-manager';
 import { GChatClient } from '../services/gchat/client';
@@ -12,32 +13,10 @@ import { readStdin, prompt } from '../utils/stdin';
 import { printGChatSendResult, printGChatMessageList, printGChatMessage, printGChatSpaceList } from '../utils/output';
 import type { GChatCredentials, GChatWebhookCredentials, GChatOAuthCredentials } from '../types/gchat';
 
-async function getGChatClient(profileName: string): Promise<{ client: GChatClient; profile: string }> {
-  const profile = await getProfile('gchat', profileName);
-
-  if (!profile) {
-    throw new CliError(
-      'PROFILE_NOT_FOUND',
-      `Profile "${profileName}" not found for gchat`,
-      'Run: agentio gchat profile add'
-    );
-  }
-
-  const credentials = await getCredentials<GChatCredentials>('gchat', profile);
-
-  if (!credentials) {
-    throw new CliError(
-      'AUTH_FAILED',
-      `No credentials found for gchat profile "${profile}"`,
-      `Run: agentio gchat profile add --profile ${profile}`
-    );
-  }
-
-  return {
-    client: new GChatClient(credentials),
-    profile,
-  };
-}
+const getGChatClient = createClientGetter<GChatCredentials, GChatClient>({
+  service: 'gchat',
+  createClient: (credentials) => new GChatClient(credentials),
+});
 
 export function registerGChatCommands(program: Command): void {
   const gchat = program

package/src/commands/github.ts

@@ -1,39 +1,18 @@
 import { Command } from 'commander';
-import { setCredentials, getCredentials } from '../auth/token-store';
-import { setProfile, getProfile } from '../config/config-manager';
+import { setCredentials } from '../auth/token-store';
+import { setProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
+import { createClientGetter } from '../utils/client-factory';
 import { GitHubClient } from '../services/github/client';
 import { performGitHubOAuthFlow } from '../auth/github-oauth';
 import { generateExportData } from './config';
 import { CliError, handleError } from '../utils/errors';
 import type { GitHubCredentials } from '../types/github';
 
-async function getGitHubClient(profileName: string): Promise<{ client: GitHubClient; profile: string }> {
-  const profile = await getProfile('github', profileName);
-
-  if (!profile) {
-    throw new CliError(
-      'PROFILE_NOT_FOUND',
-      `Profile "${profileName}" not found for github`,
-      'Run: agentio github profile add'
-    );
-  }
-
-  const credentials = await getCredentials<GitHubCredentials>('github', profile);
-
-  if (!credentials) {
-    throw new CliError(
-      'AUTH_FAILED',
-      `No credentials found for github profile "${profile}"`,
-      `Run: agentio github profile add --profile ${profile}`
-    );
-  }
-
-  return {
-    client: new GitHubClient(credentials),
-    profile,
-  };
-}
+const getGitHubClient = createClientGetter<GitHubCredentials, GitHubClient>({
+  service: 'github',
+  createClient: (credentials) => new GitHubClient(credentials),
+});
 
 function parseRepo(repo: string): { owner: string; name: string } {
   const parts = repo.split('/');

package/src/commands/slack.ts

@@ -1,40 +1,19 @@
 import { Command } from 'commander';
 import { readFile } from 'fs/promises';
-import { setCredentials, getCredentials } from '../auth/token-store';
-import { setProfile, getProfile } from '../config/config-manager';
+import { setCredentials } from '../auth/token-store';
+import { setProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
+import { createClientGetter } from '../utils/client-factory';
 import { SlackClient } from '../services/slack/client';
 import { CliError, handleError } from '../utils/errors';
 import { readStdin, prompt } from '../utils/stdin';
 import { printSlackSendResult } from '../utils/output';
 import type { SlackCredentials, SlackWebhookCredentials } from '../types/slack';
 
-async function getSlackClient(profileName: string): Promise<{ client: SlackClient; profile: string }> {
-  const profile = await getProfile('slack', profileName);
-
-  if (!profile) {
-    throw new CliError(
-      'PROFILE_NOT_FOUND',
-      `Profile "${profileName}" not found for slack`,
-      'Run: agentio slack profile add'
-    );
-  }
-
-  const credentials = await getCredentials<SlackCredentials>('slack', profile);
-
-  if (!credentials) {
-    throw new CliError(
-      'AUTH_FAILED',
-      `No credentials found for slack profile "${profile}"`,
-      `Run: agentio slack profile add --profile ${profile}`
-    );
-  }
-
-  return {
-    client: new SlackClient(credentials),
-    profile,
-  };
-}
+const getSlackClient = createClientGetter<SlackCredentials, SlackClient>({
+  service: 'slack',
+  createClient: (credentials) => new SlackClient(credentials),
+});
 
 export function registerSlackCommands(program: Command): void {
   const slack = program

package/src/commands/sql.ts

@@ -1,38 +1,17 @@
 import { Command } from 'commander';
-import { setCredentials, getCredentials } from '../auth/token-store';
-import { setProfile, getProfile } from '../config/config-manager';
+import { setCredentials } from '../auth/token-store';
+import { setProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
+import { createClientGetter } from '../utils/client-factory';
 import { SqlClient } from '../services/sql/client';
 import { CliError, handleError } from '../utils/errors';
 import { readStdin, prompt } from '../utils/stdin';
 import type { SqlCredentials } from '../types/sql';
 
-async function getSqlClient(profileName: string): Promise<{ client: SqlClient; profile: string }> {
-  const profile = await getProfile('sql', profileName);
-
-  if (!profile) {
-    throw new CliError(
-      'PROFILE_NOT_FOUND',
-      `Profile "${profileName}" not found for sql`,
-      'Run: agentio sql profile add'
-    );
-  }
-
-  const credentials = await getCredentials<SqlCredentials>('sql', profile);
-
-  if (!credentials) {
-    throw new CliError(
-      'AUTH_FAILED',
-      `No credentials found for sql profile "${profile}"`,
-      `Run: agentio sql profile add --profile ${profile}`
-    );
-  }
-
-  return {
-    client: new SqlClient(credentials),
-    profile,
-  };
-}
+const getSqlClient = createClientGetter<SqlCredentials, SqlClient>({
+  service: 'sql',
+  createClient: (credentials) => new SqlClient(credentials),
+});
 
 function extractDisplayName(url: string): string {
   try {

package/src/commands/status.ts

@@ -48,7 +48,7 @@ async function createServiceClient(
 
     case 'telegram': {
       const creds = credentials as TelegramCredentials;
-      return new TelegramClient(creds.bot_token, creds.channel_id);
+      return new TelegramClient(creds.botToken, creds.channelId);
     }
 
     case 'github': {

package/src/commands/telegram.ts

@@ -1,38 +1,17 @@
 import { Command } from 'commander';
-import { setCredentials, getCredentials } from '../auth/token-store';
-import { setProfile, getProfile } from '../config/config-manager';
+import { setCredentials } from '../auth/token-store';
+import { setProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
+import { createClientGetter } from '../utils/client-factory';
 import { TelegramClient } from '../services/telegram/client';
 import { CliError, handleError } from '../utils/errors';
 import { readStdin, prompt } from '../utils/stdin';
 import type { TelegramCredentials, TelegramSendOptions } from '../types/telegram';
 
-async function getTelegramClient(profileName: string): Promise<{ client: TelegramClient; profile: string }> {
-  const profile = await getProfile('telegram', profileName);
-
-  if (!profile) {
-    throw new CliError(
-      'PROFILE_NOT_FOUND',
-      `Profile "${profileName}" not found for telegram`,
-      'Run: agentio telegram profile add'
-    );
-  }
-
-  const credentials = await getCredentials<TelegramCredentials>('telegram', profile);
-
-  if (!credentials) {
-    throw new CliError(
-      'AUTH_FAILED',
-      `No credentials found for telegram profile "${profile}"`,
-      `Run: agentio telegram profile add --profile ${profile}`
-    );
-  }
-
-  return {
-    client: new TelegramClient(credentials.bot_token, credentials.channel_id),
-    profile,
-  };
-}
+const getTelegramClient = createClientGetter<TelegramCredentials, TelegramClient>({
+  service: 'telegram',
+  createClient: (credentials) => new TelegramClient(credentials.botToken, credentials.channelId),
+});
 
 export function registerTelegramCommands(program: Command): void {
   const telegram = program
@@ -84,7 +63,7 @@ export function registerTelegramCommands(program: Command): void {
   const profile = createProfileCommands<TelegramCredentials>(telegram, {
     service: 'telegram',
     displayName: 'Telegram',
-    getExtraInfo: (credentials) => credentials?.channel_name ? ` - ${credentials.channel_name}` : '',
+    getExtraInfo: (credentials) => credentials?.channelName ? ` - ${credentials.channelName}` : '',
   });
 
   profile
@@ -175,10 +154,10 @@ export function registerTelegramCommands(program: Command): void {
 
         // Save credentials
         const credentials: TelegramCredentials = {
-          bot_token: botToken,
-          channel_id: channelId,
-          bot_username: botInfo.username,
-          channel_name: channelName,
+          botToken: botToken,
+          channelId: channelId,
+          botUsername: botInfo.username,
+          channelName: channelName,
         };
 
         await setProfile('telegram', profileName);

package/src/commands/update.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
-import { createInterface } from 'readline';
 import { CliError, handleError } from '../utils/errors';
+import { prompt } from '../utils/stdin';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -17,20 +17,6 @@ interface GitHubRelease {
   }>;
 }
 
-function prompt(question: string): Promise<string> {
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stderr,
-  });
-
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
 function getCurrentVersion(): string {
   return pkg.version;
 }

package/src/config/config-manager.ts

@@ -7,7 +7,7 @@ import type { Config, ServiceName } from '../types/config';
 const CONFIG_DIR = join(homedir(), '.config', 'agentio');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
 
-const ALL_SERVICES: ServiceName[] = ['gmail', 'gchat', 'jira', 'slack', 'telegram', 'discourse', 'sql'];
+const ALL_SERVICES: ServiceName[] = ['gmail', 'gchat', 'github', 'jira', 'slack', 'telegram', 'discourse', 'sql'];
 
 const DEFAULT_CONFIG: Config = {
   profiles: {},

package/src/services/discourse/client.ts

@@ -7,7 +7,7 @@ import type {
   DiscourseListOptions,
 } from '../../types/discourse';
 import type { ServiceClient, ValidationResult } from '../../types/service';
-import { CliError, type ErrorCode } from '../../utils/errors';
+import { CliError, httpStatusToErrorCode } from '../../utils/errors';
 
 interface DiscourseApiResponse {
   errors?: string[];
@@ -129,7 +129,7 @@ export class DiscourseClient implements ServiceClient {
       });
 
       if (!response.ok) {
-        const errorCode = this.getErrorCode(response.status);
+        const errorCode = httpStatusToErrorCode(response.status);
         const text = await response.text();
         let message = `Discourse API error: ${response.status}`;
         try {
@@ -152,14 +152,6 @@ export class DiscourseClient implements ServiceClient {
     }
   }
 
-  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');
 

package/src/services/gchat/client.ts

@@ -1,7 +1,6 @@
 import { google } from 'googleapis';
 import type { chat_v1 } from 'googleapis';
-import { CliError } from '../../utils/errors';
-import type { ErrorCode } from '../../utils/errors';
+import { CliError, httpStatusToErrorCode, type ErrorCode } from '../../utils/errors';
 import type { ServiceClient, ValidationResult } from '../../types/service';
 import { GOOGLE_OAUTH_CONFIG } from '../../config/credentials';
 import type {
@@ -331,10 +330,9 @@ export class GChatClient implements ServiceClient {
     if (err && typeof err === 'object') {
       const error = err as Record<string, unknown>;
       const code = error.code || error.status;
-      if (code === 401) return 'AUTH_FAILED';
-      if (code === 403) return 'PERMISSION_DENIED';
-      if (code === 404) return 'NOT_FOUND';
-      if (code === 429) return 'RATE_LIMITED';
+      if (typeof code === 'number') {
+        return httpStatusToErrorCode(code);
+      }
     }
     return 'API_ERROR';
   }

package/src/services/gmail/client.ts

@@ -186,8 +186,9 @@ export class GmailClient implements ServiceClient {
         messages,
         total: response.data.resultSizeEstimate || messages.length,
       };
-    } catch (error: any) {
-      throw new CliError('API_ERROR', `Gmail API error: ${error.message}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Gmail API error: ${message}`);
     }
   }
 
@@ -209,11 +210,12 @@ export class GmailClient implements ServiceClient {
       }
 
       return { ...message, body };
-    } catch (error: any) {
-      if (error.code === 404) {
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
         throw new CliError('NOT_FOUND', `Message not found: ${messageId}`);
       }
-      throw new CliError('API_ERROR', `Gmail API error: ${error.message}`);
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Gmail API error: ${message}`);
     }
   }
 
@@ -249,12 +251,13 @@ export class GmailClient implements ServiceClient {
       }
 
       return results;
-    } catch (error: any) {
+    } catch (error) {
       if (error instanceof CliError) throw error;
-      if (error.code === 404) {
+      if (this.isNotFoundError(error)) {
         throw new CliError('NOT_FOUND', `Message not found: ${messageId}`);
       }
-      throw new CliError('API_ERROR', `Gmail API error: ${error.message}`);
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Gmail API error: ${message}`);
     }
   }
 
@@ -307,8 +310,9 @@ export class GmailClient implements ServiceClient {
         threadId: response.data.threadId!,
         labelIds: response.data.labelIds || ['SENT'],
       };
-    } catch (error: any) {
-      throw new CliError('API_ERROR', `Failed to send email: ${error.message}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to send email: ${message}`);
     }
   }
 
@@ -453,9 +457,10 @@ export class GmailClient implements ServiceClient {
         mimeType,
         base64: Buffer.from(content).toString('base64'),
       };
-    } catch (error: any) {
+    } catch (error) {
       if (error instanceof CliError) throw error;
-      throw new CliError('API_ERROR', `Failed to read attachment ${attachment.path}: ${error.message}`);
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to read attachment ${attachment.path}: ${message}`);
     }
   }
 
@@ -510,9 +515,10 @@ export class GmailClient implements ServiceClient {
         threadId: response.data.threadId!,
         labelIds: response.data.labelIds || ['SENT'],
       };
-    } catch (error: any) {
+    } catch (error) {
       if (error instanceof CliError) throw error;
-      throw new CliError('API_ERROR', `Failed to send reply: ${error.message}`);
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to send reply: ${message}`);
     }
   }
 
@@ -525,11 +531,12 @@ export class GmailClient implements ServiceClient {
           removeLabelIds: ['INBOX'],
         },
       });
-    } catch (error: any) {
-      if (error.code === 404) {
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
         throw new CliError('NOT_FOUND', `Message not found: ${messageId}`);
       }
-      throw new CliError('API_ERROR', `Failed to archive: ${error.message}`);
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to archive: ${message}`);
     }
   }
 
@@ -542,11 +549,19 @@ export class GmailClient implements ServiceClient {
           ? { removeLabelIds: ['UNREAD'] }
           : { addLabelIds: ['UNREAD'] },
       });
-    } catch (error: any) {
-      if (error.code === 404) {
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
         throw new CliError('NOT_FOUND', `Message not found: ${messageId}`);
       }
-      throw new CliError('API_ERROR', `Failed to update message: ${error.message}`);
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to update message: ${message}`);
+    }
+  }
+
+  private isNotFoundError(error: unknown): boolean {
+    if (error && typeof error === 'object' && 'code' in error) {
+      return (error as { code: unknown }).code === 404;
     }
+    return false;
   }
 }

package/src/services/jira/client.ts

@@ -1,4 +1,4 @@
-import { CliError, type ErrorCode } from '../../utils/errors';
+import { CliError, httpStatusToErrorCode } from '../../utils/errors';
 import type { ServiceClient, ValidationResult } from '../../types/service';
 import type {
   JiraCredentials,
@@ -86,7 +86,7 @@ export class JiraClient implements ServiceClient {
 
     if (!response.ok) {
       const errorText = await response.text();
-      const code = this.getErrorCode(response.status);
+      const code = httpStatusToErrorCode(response.status);
       throw new CliError(code, `JIRA API error: ${errorText}`);
     }
 
@@ -98,14 +98,6 @@ export class JiraClient implements ServiceClient {
     return response.json();
   }
 
-  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 listProjects(options: JiraProjectListOptions = {}): Promise<JiraProject[]> {
     const params = new URLSearchParams();
     if (options.maxResults) {

package/src/services/slack/client.ts

@@ -1,4 +1,4 @@
-import { CliError } from '../../utils/errors';
+import { CliError, httpStatusToErrorCode } from '../../utils/errors';
 import type { ServiceClient, ValidationResult } from '../../types/service';
 import type {
   SlackCredentials,
@@ -54,7 +54,7 @@ export class SlackClient implements ServiceClient {
       if (!response.ok) {
         const error = await response.text();
         throw new CliError(
-          this.getErrorCode(response.status),
+          httpStatusToErrorCode(response.status),
           `Failed to send message via webhook: ${response.status} ${error}`,
           'Check that the webhook URL is valid and the app has permission to post'
         );
@@ -74,11 +74,4 @@ export class SlackClient implements ServiceClient {
     }
   }
 
-  private getErrorCode(status: number): 'AUTH_FAILED' | 'PERMISSION_DENIED' | 'NOT_FOUND' | 'RATE_LIMITED' | 'API_ERROR' {
-    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/types/telegram.ts

@@ -1,8 +1,8 @@
 export interface TelegramCredentials {
-  bot_token: string;
-  channel_id: string;
-  bot_username?: string;
-  channel_name?: string;
+  botToken: string;
+  channelId: string;
+  botUsername?: string;
+  channelName?: string;
 }
 
 export interface TelegramBotInfo {