@plosson/agentio 0.2.3 → 0.3.1

package/package.json

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

package/src/auth/oauth.ts

@@ -14,6 +14,8 @@ const GCHAT_SCOPES = [
   'https://www.googleapis.com/auth/chat.messages.create',     // send messages
   'https://www.googleapis.com/auth/chat.messages.readonly',   // read messages (get operations)
   'https://www.googleapis.com/auth/chat.spaces.readonly',     // read space info and list
+  'https://www.googleapis.com/auth/chat.memberships.readonly', // read space members
+  'https://www.googleapis.com/auth/userinfo.email',           // get user email for profile naming
 ];
 
 const PORT_RANGE_START = 3000;

package/src/auth/token-manager.ts

@@ -10,16 +10,14 @@ const TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1000; // 5 minutes
 
 export async function getValidTokens(
   service: ServiceName,
-  profileName?: string
+  profileName: string
 ): Promise<{ tokens: OAuthTokens; profile: string }> {
   const profile = await getProfile(service, profileName);
 
   if (!profile) {
     throw new CliError(
       'PROFILE_NOT_FOUND',
-      profileName
-        ? `Profile "${profileName}" not found for ${service}`
-        : `No default profile configured for ${service}`,
+      `Profile "${profileName}" not found for ${service}`,
       `Run: agentio ${service} profile add`
     );
   }

package/src/commands/config.ts

@@ -3,12 +3,27 @@ import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'crypt
 import { readFile, writeFile } from 'fs/promises';
 import { existsSync } from 'fs';
 import { join } from 'path';
+import { createInterface } from 'readline';
 import { loadConfig, saveConfig, setEnv, unsetEnv, listEnv } from '../config/config-manager';
 import { getAllCredentials, setAllCredentials } from '../auth/token-store';
 import { CliError, handleError } from '../utils/errors';
 import type { Config } from '../types/config';
 import type { StoredCredentials } from '../types/tokens';
 
+async function confirm(message: string): Promise<boolean> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`${message} [y/N] `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
 const ALGORITHM = 'aes-256-gcm';
 
 interface ExportedData {
@@ -231,13 +246,6 @@ export function registerConfigCommands(program: Command): void {
             }
           }
 
-          // Merge defaults (only if not set)
-          for (const [service, defaultProfile] of Object.entries(exportData.config.defaults)) {
-            if (defaultProfile && !(currentConfig.defaults as Record<string, string | undefined>)[service]) {
-              (currentConfig.defaults as Record<string, string>)[service] = defaultProfile;
-            }
-          }
-
           // Merge credentials
           for (const [service, profiles] of Object.entries(exportData.credentials)) {
             if (!currentCredentials[service]) {
@@ -315,4 +323,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

@@ -4,7 +4,7 @@ import { setProfile, getProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
 import { DiscourseClient } from '../services/discourse/client';
 import { CliError, handleError } from '../utils/errors';
-import { prompt, resolveProfileName } from '../utils/stdin';
+import { prompt } from '../utils/stdin';
 import type { DiscourseCredentials } from '../types/discourse';
 import {
   printDiscourseTopicList,
@@ -13,16 +13,14 @@ import {
 } from '../utils/output';
 
 async function getDiscourseClient(
-  profileName?: string
+  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',
+      `Profile "${profileName}" not found for discourse`,
       'Run: agentio discourse profile add'
     );
   }
@@ -50,7 +48,7 @@ export function registerDiscourseCommands(program: Command): void {
   discourse
     .command('list')
     .description('List latest topics')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--category <slug>', 'Filter by category slug or name')
     .option('--page <number>', 'Page number (0-indexed)', '0')
     .action(async (options) => {
@@ -71,7 +69,7 @@ export function registerDiscourseCommands(program: Command): void {
     .command('get')
     .description('Get a topic with its posts')
     .argument('<topic-id>', 'Topic ID')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .action(async (topicId: string, options) => {
       try {
         const id = parseInt(topicId, 10);
@@ -91,7 +89,7 @@ export function registerDiscourseCommands(program: Command): void {
   discourse
     .command('categories')
     .description('List all categories')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .action(async (options) => {
       try {
         const { client } = await getDiscourseClient(options.profile);
@@ -112,11 +110,9 @@ export function registerDiscourseCommands(program: Command): void {
   profile
     .command('add')
     .description('Add a new Discourse profile')
-    .option('--profile <name>', 'Profile name', 'default')
+    .option('--profile <name>', 'Profile name (auto-detected from username if not provided)')
     .action(async (options) => {
       try {
-        const profileName = await resolveProfileName('discourse', options.profile);
-
         console.error('\nDiscourse Setup\n');
 
         // Step 1: Get base URL
@@ -196,6 +192,9 @@ export function registerDiscourseCommands(program: Command): void {
         console.error(`\nConnected to ${normalizedUrl}`);
         console.error(`Authenticated as ${username}\n`);
 
+        // Auto-name based on username
+        const profileName = options.profile || username.trim();
+
         // Save credentials
         await setProfile('discourse', profileName);
         await setCredentials('discourse', profileName, credentials);

package/src/commands/gchat.ts

@@ -8,19 +8,17 @@ import { performOAuthFlow } from '../auth/oauth';
 import { createGoogleAuth } from '../auth/token-manager';
 import { GChatClient } from '../services/gchat/client';
 import { CliError, handleError } from '../utils/errors';
-import { readStdin, prompt, resolveProfileName } from '../utils/stdin';
-import { printGChatSendResult, printGChatMessageList, printGChatMessage } from '../utils/output';
+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 }> {
+async function getGChatClient(profileName: string): Promise<{ client: GChatClient; profile: string }> {
   const profile = await getProfile('gchat', profileName);
 
   if (!profile) {
     throw new CliError(
       'PROFILE_NOT_FOUND',
-      profileName
-        ? `Profile "${profileName}" not found for gchat`
-        : 'No default profile configured for gchat',
+      `Profile "${profileName}" not found for gchat`,
       'Run: agentio gchat profile add'
     );
   }
@@ -49,7 +47,7 @@ export function registerGChatCommands(program: Command): void {
   gchat
     .command('send')
     .description('Send a message to Google Chat')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--space <id>', 'Space ID (required for OAuth profiles)')
     .option('--thread <id>', 'Thread ID (optional)')
     .option('--json [file]', 'Send rich message from JSON file (or stdin if no file specified)')
@@ -134,15 +132,19 @@ export function registerGChatCommands(program: Command): void {
   gchat
     .command('list')
     .description('List messages from a Google Chat space (OAuth profiles only)')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .requiredOption('--space <id>', 'Space ID')
     .option('--limit <n>', 'Number of messages', '10')
+    .option('--thread <id>', 'Filter by thread ID')
+    .option('--since <date>', 'Only messages after this date (YYYY-MM-DD)')
     .action(async (options) => {
       try {
         const { client } = await getGChatClient(options.profile);
         const messages = await client.list({
           spaceId: options.space,
           limit: parseInt(options.limit, 10),
+          threadId: options.thread,
+          since: options.since ? new Date(options.since) : undefined,
         });
 
         printGChatMessageList(messages);
@@ -154,7 +156,7 @@ export function registerGChatCommands(program: Command): void {
   gchat
     .command('get <message-id>')
     .description('Get a message from a Google Chat space (OAuth profiles only)')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .requiredOption('--space <id>', 'Space ID')
     .action(async (messageId: string, options) => {
       try {
@@ -170,6 +172,27 @@ export function registerGChatCommands(program: Command): void {
       }
     });
 
+  gchat
+    .command('spaces')
+    .description('List available Google Chat spaces (OAuth profiles only)')
+    .requiredOption('--profile <name>', 'Profile name')
+    .option('--filter <text>', 'Filter spaces by name (case-insensitive)')
+    .action(async (options) => {
+      try {
+        const { client } = await getGChatClient(options.profile);
+        let spaces = await client.listSpaces();
+
+        if (options.filter) {
+          const filterLower = options.filter.toLowerCase();
+          spaces = spaces.filter(s => s.displayName.toLowerCase().includes(filterLower));
+        }
+
+        printGChatSpaceList(spaces);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
   // Profile management
   const profile = createProfileCommands<GChatCredentials>(gchat, {
     service: 'gchat',
@@ -180,19 +203,24 @@ export function registerGChatCommands(program: Command): void {
   profile
     .command('add')
     .description('Add a new Google Chat profile (webhook or OAuth)')
-    .option('--profile <name>', 'Profile name', 'default')
+    .option('--profile <name>', 'Profile name (required for webhook, auto-detected for OAuth)')
     .action(async (options) => {
       try {
-        const profileName = await resolveProfileName('gchat', options.profile);
-
         console.error('\nGoogle Chat Setup\n');
 
         const profileType = await prompt('Choose profile type (webhook/oauth): ');
 
         if (profileType.toLowerCase() === 'webhook') {
-          await setupWebhookProfile(profileName);
+          if (!options.profile) {
+            throw new CliError(
+              'INVALID_PARAMS',
+              'Profile name is required for webhook profiles',
+              'Run: agentio gchat profile add --profile <name>'
+            );
+          }
+          await setupWebhookProfile(options.profile);
         } else if (profileType.toLowerCase() === 'oauth') {
-          await setupOAuthProfile(profileName);
+          await setupOAuthProfile(options.profile);
         } else {
           throw new CliError('INVALID_PARAMS', 'Profile type must be "webhook" or "oauth"');
         }
@@ -257,27 +285,46 @@ async function setupWebhookProfile(profileName: string): Promise<void> {
   printProfileSetupSuccess(profileName, 'webhook');
 }
 
-async function setupOAuthProfile(profileName: string): Promise<void> {
+async function setupOAuthProfile(profileNameOverride?: string): Promise<void> {
   console.error('OAuth Setup\n');
   console.error('Starting OAuth flow for Google Chat profile...\n');
 
   const tokens = await performOAuthFlow('gchat');
+  const auth = createGoogleAuth(tokens);
 
-  // Optionally fetch user info - Chat API doesn't have a getProfile like Gmail
-  // For now, just validate the token works
+  // Fetch user email for profile naming
+  let userEmail: string;
+  try {
+    const oauth2 = google.oauth2({ version: 'v2', auth });
+    const userInfo = await oauth2.userinfo.get();
+    userEmail = userInfo.data.email || '';
+    if (!userEmail) {
+      throw new Error('No email returned');
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new CliError(
+      'AUTH_FAILED',
+      `Failed to fetch user email: ${errorMessage}`,
+      'Ensure the account has an email address'
+    );
+  }
+
+  // Validate the token works with Chat API
   try {
-    const auth = createGoogleAuth(tokens);
     const chat = google.chat({ version: 'v1', auth });
-    // Simple validation: list spaces
     await chat.spaces.list({ pageSize: 1 });
   } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
     throw new CliError(
       'AUTH_FAILED',
-      'Failed to validate Google Chat access. Check OAuth scopes.',
-      'Try again with: agentio gchat profile add --profile ' + profileName
+      `Failed to validate Google Chat access: ${errorMessage}`,
+      'Google Chat API requires a Google Workspace account. Personal Gmail accounts cannot use the Chat API.'
     );
   }
 
+  const profileName = profileNameOverride || userEmail;
+
   const credentials: GChatOAuthCredentials = {
     type: 'oauth',
     accessToken: tokens.access_token,
@@ -285,6 +332,7 @@ async function setupOAuthProfile(profileName: string): Promise<void> {
     expiryDate: tokens.expiry_date,
     tokenType: tokens.token_type,
     scope: tokens.scope,
+    email: userEmail,
   };
 
   await setProfile('gchat', profileName);

package/src/commands/github.ts

@@ -6,18 +6,15 @@ import { GitHubClient } from '../services/github/client';
 import { performGitHubOAuthFlow } from '../auth/github-oauth';
 import { generateExportData } from './config';
 import { CliError, handleError } from '../utils/errors';
-import { resolveProfileName } from '../utils/stdin';
 import type { GitHubCredentials } from '../types/github';
 
-async function getGitHubClient(profileName?: string): Promise<{ client: GitHubClient; profile: string }> {
+async function getGitHubClient(profileName: string): Promise<{ client: GitHubClient; profile: string }> {
   const profile = await getProfile('github', profileName);
 
   if (!profile) {
     throw new CliError(
       'PROFILE_NOT_FOUND',
-      profileName
-        ? `Profile "${profileName}" not found for github`
-        : 'No default profile configured for github',
+      `Profile "${profileName}" not found for github`,
       'Run: agentio github profile add'
     );
   }
@@ -59,7 +56,7 @@ export function registerGitHubCommands(program: Command): void {
     .command('install')
     .description('Install AGENTIO_KEY and AGENTIO_CONFIG as GitHub Actions secrets')
     .argument('<repo>', 'Repository in owner/repo format')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .action(async (repo: string, options) => {
       try {
         // Validate repo format
@@ -94,7 +91,7 @@ export function registerGitHubCommands(program: Command): void {
     .command('uninstall')
     .description('Remove AGENTIO_KEY and AGENTIO_CONFIG secrets from a repository')
     .argument('<repo>', 'Repository in owner/repo format')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .action(async (repo: string, options) => {
       try {
         // Validate repo format
@@ -128,11 +125,9 @@ export function registerGitHubCommands(program: Command): void {
   profile
     .command('add')
     .description('Add a new GitHub profile')
-    .option('--profile <name>', 'Profile name', 'default')
+    .option('--profile <name>', 'Profile name (auto-detected from username if not provided)')
     .action(async (options) => {
       try {
-        const profileName = await resolveProfileName('github', options.profile);
-
         console.error('\nGitHub Setup\n');
         console.error('This will open your browser to authorize agentio with GitHub.');
         console.error('You will need to grant access to repositories where you want to set secrets.\n');
@@ -154,6 +149,8 @@ export function registerGitHubCommands(program: Command): void {
         credentials.username = user.login;
         credentials.email = user.email;
 
+        const profileName = options.profile || user.login;
+
         console.error(`\nAuthenticated as: ${user.login}${user.email ? ` (${user.email})` : ''}`);
 
         // Save credentials

package/src/commands/gmail.ts

@@ -10,7 +10,7 @@ import { performOAuthFlow } from '../auth/oauth';
 import { GmailClient } from '../services/gmail/client';
 import { printMessageList, printMessage, printSendResult, printArchived, printMarked, printAttachmentList, printAttachmentDownloaded, raw } from '../utils/output';
 import { CliError, handleError } from '../utils/errors';
-import { readStdin, resolveProfileName } from '../utils/stdin';
+import { readStdin } from '../utils/stdin';
 import type { GmailAttachment } from '../types/gmail';
 
 function escapeHtml(text: string): string {
@@ -68,7 +68,7 @@ function findChromePath(): string | null {
   return null;
 }
 
-async function getGmailClient(profileName?: string): Promise<{ client: GmailClient; profile: string }> {
+async function getGmailClient(profileName: string): Promise<{ client: GmailClient; profile: string }> {
   const { tokens, profile } = await getValidTokens('gmail', profileName);
   const auth = createGoogleAuth(tokens);
   return { client: new GmailClient(auth), profile };
@@ -82,7 +82,7 @@ export function registerGmailCommands(program: Command): void {
   gmail
     .command('list')
     .description('List messages')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--limit <n>', 'Number of messages', '10')
     .option('--query <query>', 'Gmail search query (see "gmail search --help" for syntax)')
     .option('--label <label>', 'Filter by label (repeatable)', (val, acc: string[]) => [...acc, val], [])
@@ -103,7 +103,7 @@ export function registerGmailCommands(program: Command): void {
   gmail
     .command('get <message-id>')
     .description('Get a message')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--format <format>', 'Body format: text, html, or raw', 'text')
     .option('--body-only', 'Output only the message body')
     .action(async (messageId: string, options) => {
@@ -124,7 +124,7 @@ export function registerGmailCommands(program: Command): void {
     .command('search')
     .description('Search messages using Gmail query syntax')
     .requiredOption('--query <query>', 'Search query')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--limit <n>', 'Max results', '10')
     .addHelpText('after', `
 Query Syntax Examples:
@@ -178,7 +178,7 @@ Query Syntax Examples:
   gmail
     .command('send')
     .description('Send an email')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .requiredOption('--to <email>', 'Recipient (repeatable)', (val, acc: string[]) => [...acc, val], [])
     .option('--cc <email>', 'CC recipient (repeatable)', (val, acc: string[]) => [...acc, val], [])
     .option('--bcc <email>', 'BCC recipient (repeatable)', (val, acc: string[]) => [...acc, val], [])
@@ -246,7 +246,7 @@ Query Syntax Examples:
   gmail
     .command('reply')
     .description('Reply to a thread')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .requiredOption('--thread-id <id>', 'Thread ID')
     .option('--body <body>', 'Reply body (or pipe via stdin)')
     .option('--html', 'Treat body as HTML')
@@ -277,7 +277,7 @@ Query Syntax Examples:
   gmail
     .command('archive <message-id...>')
     .description('Archive one or more messages')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .action(async (messageIds: string[], options) => {
       try {
         const { client } = await getGmailClient(options.profile);
@@ -293,7 +293,7 @@ Query Syntax Examples:
   gmail
     .command('mark <message-id...>')
     .description('Mark one or more messages as read or unread')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--read', 'Mark as read')
     .option('--unread', 'Mark as unread')
     .action(async (messageIds: string[], options) => {
@@ -318,7 +318,7 @@ Query Syntax Examples:
   gmail
     .command('attachment <message-id>')
     .description('Download attachments from a message')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--name <filename>', 'Download specific attachment by filename (downloads all if not specified)')
     .option('--output <dir>', 'Output directory', '.')
     .action(async (messageId: string, options) => {
@@ -361,7 +361,7 @@ Query Syntax Examples:
   gmail
     .command('export <message-id>')
     .description('Export a message as PDF')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--output <path>', 'Output file path', 'message.pdf')
     .action(async (messageId: string, options) => {
       try {
@@ -452,12 +452,10 @@ ${emailHeader}
   profile
     .command('add')
     .description('Add a new Gmail profile')
-    .option('--profile <name>', 'Profile name', 'default')
+    .option('--profile <name>', 'Profile name (auto-detected from email if not provided)')
     .action(async (options) => {
       try {
-        const profileName = await resolveProfileName('gmail', options.profile);
-
-        console.error(`Starting OAuth flow for Gmail profile "${profileName}"...`);
+        console.error('Starting OAuth flow for Gmail...\n');
 
         const tokens = await performOAuthFlow('gmail');
 
@@ -467,13 +465,17 @@ ${emailHeader}
         const userProfile = await gmailApi.users.getProfile({ userId: 'me' });
         const email = userProfile.data.emailAddress;
 
+        if (!email) {
+          throw new CliError('AUTH_FAILED', 'Could not fetch email from Gmail', 'Try again or specify --profile manually');
+        }
+
+        const profileName = options.profile || email;
+
         await setProfile('gmail', profileName);
         await setCredentials('gmail', profileName, { ...tokens, email });
 
-        console.log(`\nSuccess! Profile "${profileName}" for Gmail is now configured.`);
-        if (email) {
-          console.log(`   Email: ${email}`);
-        }
+        console.log(`\nSuccess! Profile "${profileName}" configured.`);
+        console.log(`   Email: ${email}`);
       } catch (error) {
         handleError(error);
       }

package/src/commands/jira.ts

@@ -5,7 +5,7 @@ import { createProfileCommands } from '../utils/profile-commands';
 import { performJiraOAuthFlow, refreshJiraToken, type AtlassianSite } from '../auth/jira-oauth';
 import { JiraClient } from '../services/jira/client';
 import { CliError, handleError } from '../utils/errors';
-import { readStdin, prompt, resolveProfileName } from '../utils/stdin';
+import { readStdin, prompt } from '../utils/stdin';
 import {
   printJiraProjectList,
   printJiraIssueList,
@@ -46,15 +46,13 @@ async function ensureValidToken(credentials: JiraCredentials, profile: string):
   return credentials;
 }
 
-async function getJiraClient(profileName?: string): Promise<{ client: JiraClient; profile: string }> {
+async function getJiraClient(profileName: string): Promise<{ client: JiraClient; profile: string }> {
   const profile = await getProfile('jira', profileName);
 
   if (!profile) {
     throw new CliError(
       'PROFILE_NOT_FOUND',
-      profileName
-        ? `Profile "${profileName}" not found for jira`
-        : 'No default profile configured for jira',
+      `Profile "${profileName}" not found for jira`,
       'Run: agentio jira profile add'
     );
   }
@@ -87,7 +85,7 @@ export function registerJiraCommands(program: Command): void {
   jira
     .command('projects')
     .description('List JIRA projects')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--limit <number>', 'Maximum number of projects', '50')
     .action(async (options) => {
       try {
@@ -105,7 +103,7 @@ export function registerJiraCommands(program: Command): void {
   jira
     .command('search')
     .description('Search JIRA issues')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--jql <query>', 'JQL query')
     .option('--project <key>', 'Project key')
     .option('--status <status>', 'Issue status')
@@ -132,7 +130,7 @@ export function registerJiraCommands(program: Command): void {
     .command('get')
     .description('Get JIRA issue details')
     .argument('<issue-key>', 'Issue key (e.g., PROJ-123)')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .action(async (issueKey: string, options) => {
       try {
         const { client } = await getJiraClient(options.profile);
@@ -149,7 +147,7 @@ export function registerJiraCommands(program: Command): void {
     .description('Add a comment to an issue')
     .argument('<issue-key>', 'Issue key (e.g., PROJ-123)')
     .argument('[body]', 'Comment body (or pipe via stdin)')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .action(async (issueKey: string, body: string | undefined, options) => {
       try {
         let text = body;
@@ -175,7 +173,7 @@ export function registerJiraCommands(program: Command): void {
     .command('transitions')
     .description('List available transitions for an issue')
     .argument('<issue-key>', 'Issue key (e.g., PROJ-123)')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .action(async (issueKey: string, options) => {
       try {
         const { client } = await getJiraClient(options.profile);
@@ -192,7 +190,7 @@ export function registerJiraCommands(program: Command): void {
     .description('Transition an issue to a new status')
     .argument('<issue-key>', 'Issue key (e.g., PROJ-123)')
     .argument('<transition-id>', 'Transition ID (use "transitions" command to see available)')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .action(async (issueKey: string, transitionId: string, options) => {
       try {
         const { client } = await getJiraClient(options.profile);
@@ -213,11 +211,9 @@ export function registerJiraCommands(program: Command): void {
   profile
     .command('add')
     .description('Add a new JIRA profile with OAuth authentication')
-    .option('--profile <name>', 'Profile name', 'default')
+    .option('--profile <name>', 'Profile name (auto-detected from site URL if not provided)')
     .action(async (options) => {
       try {
-        const profileName = await resolveProfileName('jira', options.profile);
-
         console.error('\nJIRA OAuth Setup\n');
 
         // Site selection callback
@@ -242,6 +238,10 @@ export function registerJiraCommands(program: Command): void {
 
         console.error(`\nAuthorized for site: ${result.siteUrl}\n`);
 
+        // Auto-name based on site hostname
+        const siteHostname = new URL(result.siteUrl).hostname;
+        const profileName = options.profile || siteHostname;
+
         // Save credentials
         const credentials: JiraCredentials = {
           accessToken: result.accessToken,

package/src/commands/slack.ts

@@ -5,19 +5,17 @@ import { setProfile, getProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
 import { SlackClient } from '../services/slack/client';
 import { CliError, handleError } from '../utils/errors';
-import { readStdin, prompt, resolveProfileName } from '../utils/stdin';
+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 }> {
+async function getSlackClient(profileName: string): Promise<{ client: SlackClient; profile: string }> {
   const profile = await getProfile('slack', profileName);
 
   if (!profile) {
     throw new CliError(
       'PROFILE_NOT_FOUND',
-      profileName
-        ? `Profile "${profileName}" not found for slack`
-        : 'No default profile configured for slack',
+      `Profile "${profileName}" not found for slack`,
       'Run: agentio slack profile add'
     );
   }
@@ -46,7 +44,7 @@ export function registerSlackCommands(program: Command): void {
   slack
     .command('send')
     .description('Send a message to Slack')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--json [file]', 'Send Block Kit message from JSON file (or stdin if no file specified)')
     .argument('[message]', 'Message text (or pipe via stdin)')
     .action(async (message: string | undefined, options) => {
@@ -134,11 +132,10 @@ export function registerSlackCommands(program: Command): void {
   profile
     .command('add')
     .description('Add a new Slack profile (webhook)')
-    .option('--profile <name>', 'Profile name', 'default')
+    .requiredOption('--profile <name>', 'Profile name (required)')
     .action(async (options) => {
       try {
-        const profileName = await resolveProfileName('slack', options.profile);
-        await setupWebhookProfile(profileName);
+        await setupWebhookProfile(options.profile);
       } catch (error) {
         handleError(error);
       }

package/src/commands/sql.ts

@@ -4,18 +4,16 @@ import { setProfile, getProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
 import { SqlClient } from '../services/sql/client';
 import { CliError, handleError } from '../utils/errors';
-import { readStdin, prompt, resolveProfileName } from '../utils/stdin';
+import { readStdin, prompt } from '../utils/stdin';
 import type { SqlCredentials } from '../types/sql';
 
-async function getSqlClient(profileName?: string): Promise<{ client: SqlClient; profile: string }> {
+async function getSqlClient(profileName: string): Promise<{ client: SqlClient; profile: string }> {
   const profile = await getProfile('sql', profileName);
 
   if (!profile) {
     throw new CliError(
       'PROFILE_NOT_FOUND',
-      profileName
-        ? `Profile "${profileName}" not found for sql`
-        : 'No default profile configured for sql',
+      `Profile "${profileName}" not found for sql`,
       'Run: agentio sql profile add'
     );
   }
@@ -55,7 +53,7 @@ export function registerSqlCommands(program: Command): void {
   sql
     .command('query')
     .description('Execute a SQL query')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--limit <n>', 'Maximum rows to return', '100')
     .argument('[query]', 'SQL query (or pipe via stdin)')
     .action(async (query: string | undefined, options) => {
@@ -94,12 +92,10 @@ export function registerSqlCommands(program: Command): void {
   profile
     .command('add')
     .description('Add a new SQL database profile')
-    .option('--profile <name>', 'Profile name', 'default')
+    .option('--profile <name>', 'Profile name (auto-detected from connection if not provided)')
     .option('--interactive', 'Interactive mode: prompt for individual connection components')
     .action(async (options) => {
       try {
-        const profileName = await resolveProfileName('sql', options.profile);
-
         let url: string;
 
         if (options.interactive) {
@@ -138,6 +134,9 @@ export function registerSqlCommands(program: Command): void {
         const displayName = extractDisplayName(url);
         console.error(`\nConnected to: ${displayName}\n`);
 
+        // Auto-name based on connection display name
+        const profileName = options.profile || displayName;
+
         // Save credentials
         const credentials: SqlCredentials = {
           url,

package/src/commands/status.ts

@@ -144,7 +144,6 @@ async function createServiceClient(
 interface ProfileStatus {
   service: string;
   profile: string;
-  isDefault: boolean;
   status: 'ok' | 'invalid' | 'no-creds' | 'skipped';
   info?: string;
   error?: string;
@@ -166,7 +165,7 @@ export function registerStatusCommand(program: Command): void {
         // Collect all profile statuses
         const statuses: ProfileStatus[] = [];
 
-        for (const { service, profiles, default: defaultProfile } of allProfiles) {
+        for (const { service, profiles } of allProfiles) {
           for (const name of profiles) {
             const credentials = await getCredentials(service, name);
 
@@ -174,7 +173,6 @@ export function registerStatusCommand(program: Command): void {
               statuses.push({
                 service,
                 profile: name,
-                isDefault: name === defaultProfile,
                 status: 'no-creds',
               });
               continue;
@@ -184,7 +182,6 @@ export function registerStatusCommand(program: Command): void {
               statuses.push({
                 service,
                 profile: name,
-                isDefault: name === defaultProfile,
                 status: 'skipped',
               });
               continue;
@@ -202,7 +199,6 @@ export function registerStatusCommand(program: Command): void {
             statuses.push({
               service,
               profile: name,
-              isDefault: name === defaultProfile,
               status: result.valid ? 'ok' : 'invalid',
               info: result.info,
               error: result.error,
@@ -244,13 +240,12 @@ export function registerStatusCommand(program: Command): void {
 
         // Calculate column widths
         const serviceWidth = Math.max(...statuses.map((s) => s.service.length));
-        const profileWidth = Math.max(...statuses.map((s) => s.profile.length + (s.isDefault ? 1 : 0)));
+        const profileWidth = Math.max(...statuses.map((s) => s.profile.length));
 
         // Print each profile on one line
         for (const s of statuses) {
           const servicePad = s.service.padEnd(serviceWidth);
-          const profileName = s.profile + (s.isDefault ? '*' : '');
-          const profilePad = profileName.padEnd(profileWidth);
+          const profilePad = s.profile.padEnd(profileWidth);
 
           let statusStr: string;
           let details: string;

package/src/commands/telegram.ts

@@ -4,18 +4,16 @@ 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';
+import { readStdin, prompt } from '../utils/stdin';
 import type { TelegramCredentials, TelegramSendOptions } from '../types/telegram';
 
-async function getTelegramClient(profileName?: string): Promise<{ client: TelegramClient; profile: string }> {
+async function getTelegramClient(profileName: string): Promise<{ client: TelegramClient; profile: string }> {
   const profile = await getProfile('telegram', profileName);
 
   if (!profile) {
     throw new CliError(
       'PROFILE_NOT_FOUND',
-      profileName
-        ? `Profile "${profileName}" not found for telegram`
-        : 'No default profile configured for telegram',
+      `Profile "${profileName}" not found for telegram`,
       'Run: agentio telegram profile add'
     );
   }
@@ -44,7 +42,7 @@ export function registerTelegramCommands(program: Command): void {
   telegram
     .command('send')
     .description('Send a message to the channel')
-    .option('--profile <name>', 'Profile name')
+    .requiredOption('--profile <name>', 'Profile name')
     .option('--parse-mode <mode>', 'Message format: html or markdown')
     .option('--silent', 'Send without notification')
     .argument('[message]', 'Message text (or pipe via stdin)')
@@ -92,11 +90,9 @@ export function registerTelegramCommands(program: Command): void {
   profile
     .command('add')
     .description('Add a new Telegram bot profile')
-    .option('--profile <name>', 'Profile name', 'default')
+    .option('--profile <name>', 'Profile name (auto-detected from bot username if not provided)')
     .action(async (options) => {
       try {
-        const profileName = await resolveProfileName('telegram', options.profile);
-
         console.error('\nTelegram Bot Setup\n');
 
         // Step 1: Create bot
@@ -174,6 +170,9 @@ export function registerTelegramCommands(program: Command): void {
         console.error('    /setuserpic - Set bot photo');
         console.error('    /setdescription - Set bot description\n');
 
+        // Auto-name based on bot username
+        const profileName = options.profile || botInfo.username;
+
         // Save credentials
         const credentials: TelegramCredentials = {
           bot_token: botToken,

package/src/config/config-manager.ts

@@ -11,7 +11,6 @@ const ALL_SERVICES: ServiceName[] = ['gmail', 'gchat', 'jira', 'slack', 'telegra
 
 const DEFAULT_CONFIG: Config = {
   profiles: {},
-  defaults: {},
 };
 
 export async function ensureConfigDir(): Promise<void> {
@@ -50,21 +49,16 @@ export async function saveConfig(config: Config): Promise<void> {
 
 export async function getProfile(
   service: ServiceName,
-  profileName?: string
+  profileName: string
 ): Promise<string | null> {
   const config = await loadConfig();
-  const name = profileName || config.defaults[service];
-
-  if (!name) {
-    return null;
-  }
 
   const serviceProfiles = config.profiles[service] || [];
-  if (!serviceProfiles.includes(name)) {
+  if (!serviceProfiles.includes(profileName)) {
     return null;
   }
 
-  return name;
+  return profileName;
 }
 
 export async function setProfile(
@@ -81,11 +75,6 @@ export async function setProfile(
     config.profiles[service]!.push(profileName);
   }
 
-  // Set as default if it's the first profile for this service
-  if (!config.defaults[service]) {
-    config.defaults[service] = profileName;
-  }
-
   await saveConfig(config);
 }
 
@@ -102,27 +91,6 @@ export async function removeProfile(
 
   config.profiles[service] = serviceProfiles.filter((p) => p !== profileName);
 
-  // Clear default if it was the removed profile
-  if (config.defaults[service] === profileName) {
-    config.defaults[service] = config.profiles[service]![0];
-  }
-
-  await saveConfig(config);
-  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;
 }
@@ -130,7 +98,6 @@ export async function setDefault(
 export async function listProfiles(service?: ServiceName): Promise<{
   service: ServiceName;
   profiles: string[];
-  default?: string;
 }[]> {
   const config = await loadConfig();
   const services = service ? [service] : ALL_SERVICES;
@@ -138,7 +105,6 @@ export async function listProfiles(service?: ServiceName): Promise<{
   return services.map((svc) => ({
     service: svc,
     profiles: config.profiles[svc] || [],
-    default: config.defaults[svc],
   }));
 }
 

package/src/services/gchat/client.ts

@@ -13,6 +13,7 @@ import type {
   GChatWebhookCredentials,
   GChatOAuthCredentials,
   GChatMessage,
+  GChatSpace,
 } from '../../types/gchat';
 
 export class GChatClient implements ServiceClient {
@@ -87,6 +88,17 @@ export class GChatClient implements ServiceClient {
     return this.getViaOAuth(options);
   }
 
+  async listSpaces(): Promise<GChatSpace[]> {
+    if (this.credentials.type === 'webhook') {
+      throw new CliError(
+        'PERMISSION_DENIED',
+        'Listing spaces is not supported for webhook profiles',
+        'Use an OAuth profile to list spaces'
+      );
+    }
+    return this.listSpacesViaOAuth();
+  }
+
   private async sendViaWebhook(options: GChatSendOptions): Promise<GChatSendResult> {
     const webhookUrl = (this.credentials as GChatWebhookCredentials).webhookUrl;
 
@@ -194,9 +206,21 @@ export class GChatClient implements ServiceClient {
     const chat = google.chat({ version: 'v1', auth });
 
     try {
+      // Build filter from options
+      const filters: string[] = [];
+      if (options.threadId) {
+        filters.push(`thread.name = "spaces/${options.spaceId}/threads/${options.threadId}"`);
+      }
+      if (options.since) {
+        filters.push(`createTime > "${options.since.toISOString()}"`);
+      }
+      const filter = filters.length > 0 ? filters.join(' AND ') : undefined;
+
       const response = await chat.spaces.messages.list({
         parent: `spaces/${options.spaceId}`,
         pageSize: options.limit || 10,
+        orderBy: 'createTime desc',
+        filter,
       });
 
       const messages = response.data.messages || [];
@@ -277,6 +301,32 @@ export class GChatClient implements ServiceClient {
     }
   }
 
+  private async listSpacesViaOAuth(): Promise<GChatSpace[]> {
+    const oauthCreds = this.credentials as GChatOAuthCredentials;
+    const auth = this.createOAuthClient(oauthCreds);
+    const chat = google.chat({ version: 'v1', auth });
+
+    try {
+      const response = await chat.spaces.list({});
+
+      const spaces = response.data.spaces || [];
+      return spaces.map((space: chat_v1.Schema$Space) => ({
+        name: space.name || '',
+        displayName: space.displayName || 'Unnamed',
+        type: (space.type as 'ROOM' | 'DM') || 'ROOM',
+        description: space.spaceDetails?.description || undefined,
+      }));
+    } catch (err) {
+      const code = this.getErrorCode(err);
+      const message = this.getErrorMessage(err);
+      throw new CliError(
+        code,
+        `Failed to list spaces: ${message}`,
+        'Check that OAuth token is valid and has Chat scope'
+      );
+    }
+  }
+
   private getErrorCode(err: unknown): ErrorCode {
     if (err && typeof err === 'object') {
       const error = err as Record<string, unknown>;

package/src/types/config.ts

@@ -9,16 +9,6 @@ export interface Config {
     discourse?: string[];
     sql?: string[];
   };
-  defaults: {
-    gmail?: string;
-    gchat?: string;
-    github?: string;
-    jira?: string;
-    slack?: string;
-    telegram?: string;
-    discourse?: string;
-    sql?: string;
-  };
   env?: Record<string, string>;
 }
 

package/src/types/gchat.ts

@@ -42,6 +42,7 @@ export interface GChatOAuthCredentials {
   expiryDate?: number;
   tokenType: string;
   scope?: string;
+  email: string;
 }
 
 export type GChatCredentials = GChatWebhookCredentials | GChatOAuthCredentials;
@@ -55,6 +56,8 @@ export interface GChatSendOptions {
 export interface GChatListOptions {
   spaceId: string;
   limit?: number;
+  threadId?: string;
+  since?: Date;
 }
 
 export interface GChatGetOptions {

package/src/utils/output.ts

@@ -1,5 +1,5 @@
 import type { GmailMessage, GmailAttachmentInfo } from '../types/gmail';
-import type { GChatMessage } from '../types/gchat';
+import type { GChatMessage, GChatSpace } 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';
@@ -147,6 +147,25 @@ export function printGChatMessage(msg: GChatMessage): void {
   }
 }
 
+export function printGChatSpaceList(spaces: GChatSpace[]): void {
+  if (spaces.length === 0) {
+    console.log('No spaces found');
+    return;
+  }
+
+  console.log(`Spaces (${spaces.length})\n`);
+
+  for (const space of spaces) {
+    const spaceId = space.name.replace('spaces/', '');
+    console.log(`[${space.type}] ${space.displayName}`);
+    console.log(`    ID: ${spaceId}`);
+    if (space.description) {
+      console.log(`    Description: ${space.description}`);
+    }
+    console.log('');
+  }
+}
+
 // JIRA specific formatters
 export function printJiraProjectList(projects: JiraProject[]): void {
   if (projects.length === 0) {

package/src/utils/profile-commands.ts

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
-import { listProfiles, removeProfile, setDefault } from '../config/config-manager';
+import { listProfiles, removeProfile } from '../config/config-manager';
 import { removeCredentials, getCredentials } from '../auth/token-store';
-import { handleError, CliError } from './errors';
+import { handleError } from './errors';
 import type { ServiceName } from '../types/config';
 
 export interface ProfileCommandsOptions<T> {
@@ -26,16 +26,15 @@ export function createProfileCommands<T>(
     .action(async () => {
       try {
         const result = await listProfiles(service);
-        const { profiles, default: defaultProfile } = result[0];
+        const { profiles } = 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}`);
+            console.log(`${name}${extraInfo}`);
           }
         }
       } catch (error) {
@@ -64,27 +63,5 @@ export function createProfileCommands<T>(
       }
     });
 
-  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;
 }

package/src/utils/stdin.ts

@@ -1,6 +1,4 @@
 import { createInterface } from 'readline';
-import { getProfile } from '../config/config-manager';
-import type { ServiceName } from '../types/config';
 
 /**
  * Prompt the user for input with a question.
@@ -27,40 +25,6 @@ export async function confirm(question: string): Promise<boolean> {
   return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
 }
 
-/**
- * Resolve profile name, checking for existing profiles and prompting for override.
- * If the profile already exists, asks the user whether to override or choose a new name.
- */
-export async function resolveProfileName(
-  service: ServiceName,
-  requestedName: string
-): Promise<string> {
-  const existingProfile = await getProfile(service, requestedName);
-
-  if (!existingProfile) {
-    // Profile doesn't exist, use the requested name
-    return requestedName;
-  }
-
-  // Profile exists, ask if user wants to override
-  console.error(`\nProfile "${requestedName}" already exists for ${service}.`);
-  const shouldOverride = await confirm('Do you want to override it?');
-
-  if (shouldOverride) {
-    return requestedName;
-  }
-
-  // Ask for a new profile name
-  const newName = await prompt('Enter a new profile name: ');
-
-  if (!newName) {
-    throw new Error('Profile name is required');
-  }
-
-  // Recursively check if the new name also exists
-  return resolveProfileName(service, newName);
-}
-
 export async function readStdin(): Promise<string | null> {
   // Check if stdin is a TTY (interactive terminal)
   if (process.stdin.isTTY) {