@plosson/agentio 0.3.2 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plosson/agentio",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "description": "CLI for LLM agents to interact with communication and tracking services",
   "type": "module",
   "license": "MIT",
@@ -46,6 +46,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
     "commander": "^14.0.2",
     "googleapis": "^169.0.0",
     "libsodium-wrappers": "^0.8.1",

package/src/auth/oauth.ts

@@ -17,13 +17,35 @@ const GCHAT_SCOPES = [
   'https://www.googleapis.com/auth/userinfo.email',           // get user email for profile naming
 ];
 
-const SCOPES: Record<'gmail' | 'gchat', string[]> = {
+const GDOCS_SCOPES = [
+  'https://www.googleapis.com/auth/documents',          // read/write docs
+  'https://www.googleapis.com/auth/drive.file',         // create/access files created by this app
+  'https://www.googleapis.com/auth/drive.readonly',     // read all drive files (list, metadata, export)
+  'https://www.googleapis.com/auth/userinfo.email',     // get email for profile naming
+];
+
+const GDRIVE_READONLY_SCOPES = [
+  'https://www.googleapis.com/auth/drive.readonly',     // read all drive files (list, metadata, download)
+  'https://www.googleapis.com/auth/userinfo.email',     // get email for profile naming
+];
+
+const GDRIVE_FULL_SCOPES = [
+  'https://www.googleapis.com/auth/drive',              // full access to all drive files
+  'https://www.googleapis.com/auth/userinfo.email',     // get email for profile naming
+];
+
+const SCOPES: Record<'gmail' | 'gchat' | 'gdocs' | 'gdrive-readonly' | 'gdrive-full', string[]> = {
   gmail: GMAIL_SCOPES,
   gchat: GCHAT_SCOPES,
+  gdocs: GDOCS_SCOPES,
+  'gdrive-readonly': GDRIVE_READONLY_SCOPES,
+  'gdrive-full': GDRIVE_FULL_SCOPES,
 };
 
+export type OAuthService = 'gmail' | 'gchat' | 'gdocs' | 'gdrive-readonly' | 'gdrive-full';
+
 export async function performOAuthFlow(
-  service: 'gmail' | 'gchat'
+  service: OAuthService
 ): Promise<OAuthTokens> {
   const port = await findAvailablePort();
   const redirectUri = `http://localhost:${port}/callback`;

package/src/auth/token-manager.ts

@@ -1,6 +1,6 @@
 import { google } from 'googleapis';
 import { getCredentials, setCredentials } from './token-store';
-import { getProfile } from '../config/config-manager';
+import { resolveProfile } from '../config/config-manager';
 import { GOOGLE_OAUTH_CONFIG } from '../config/credentials';
 import { CliError } from '../utils/errors';
 import type { ServiceName } from '../types/config';
@@ -10,16 +10,18 @@ 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);
+  const { profile, error } = await resolveProfile(service, profileName);
 
   if (!profile) {
-    throw new CliError(
-      'PROFILE_NOT_FOUND',
-      `Profile "${profileName}" not found for ${service}`,
-      `Run: agentio ${service} profile add`
-    );
+    if (error === 'none') {
+      throw new CliError('PROFILE_NOT_FOUND', `No ${service} profile configured`, `Run: agentio ${service} profile add`);
+    }
+    if (error === 'multiple') {
+      throw new CliError('PROFILE_NOT_FOUND', `Multiple ${service} profiles exist`, 'Specify --profile <name>');
+    }
+    throw new CliError('PROFILE_NOT_FOUND', `Profile "${profileName}" not found for ${service}`, `Run: agentio ${service} profile add`);
   }
 
   const tokens = await getCredentials<OAuthTokens>(service, profile);

package/src/commands/config.ts

@@ -7,9 +7,15 @@ import { loadConfig, saveConfig, setEnv, unsetEnv, listEnv } from '../config/con
 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 { isInteractive, interactiveCheckbox, interactiveSelect } from '../utils/interactive';
+import type { Config, ServiceName } from '../types/config';
 import type { StoredCredentials } from '../types/tokens';
 
+interface ProfileSelection {
+  service: ServiceName;
+  profile: string;
+}
+
 const ALGORITHM = 'aes-256-gcm';
 
 interface ExportedData {
@@ -94,6 +100,7 @@ export function registerConfigCommands(program: Command): void {
     .description('Export configuration and credentials (as environment variables by default, or to a file)')
     .option('--key <key>', 'Encryption key (64 hex characters). If not provided, a random key will be generated')
     .option('--file <path>', 'Write encrypted config to file instead of outputting AGENTIO_CONFIG')
+    .option('--all', 'Export all profiles without prompting for selection')
     .action(async (options) => {
       try {
         // Validate key if provided
@@ -115,23 +122,103 @@ export function registerConfigCommands(program: Command): void {
         const configData = await loadConfig();
         const credentials = await getAllCredentials();
 
+        // Build list of all available profiles
+        const allProfiles: ProfileSelection[] = [];
+        for (const [service, profiles] of Object.entries(configData.profiles)) {
+          if (profiles) {
+            for (const profile of profiles) {
+              allProfiles.push({ service: service as ServiceName, profile });
+            }
+          }
+        }
+
+        if (allProfiles.length === 0) {
+          throw new CliError(
+            'NOT_FOUND',
+            'No profiles configured',
+            'Add profiles first with: agentio <service> profile add'
+          );
+        }
+
+        // Determine which profiles to export
+        let selectedProfiles: ProfileSelection[];
+
+        if (options.all || !isInteractive()) {
+          // Export all profiles
+          selectedProfiles = allProfiles;
+        } else {
+          // Interactive: ask user to select profiles
+          const exportAll = await interactiveSelect({
+            message: 'What would you like to export?',
+            choices: [
+              { name: `All profiles (${allProfiles.length})`, value: 'all' },
+              { name: 'Select specific profiles', value: 'select' },
+            ],
+            default: 'all',
+          });
+
+          if (exportAll === 'all') {
+            selectedProfiles = allProfiles;
+          } else {
+            selectedProfiles = await interactiveCheckbox({
+              message: 'Select profiles to export:',
+              choices: allProfiles.map((p) => ({
+                name: `${p.service}: ${p.profile}`,
+                value: p,
+                checked: false,
+              })),
+              required: true,
+            });
+          }
+        }
+
+        // Filter config and credentials based on selection
+        const filteredConfig: Config = { profiles: {} };
+        const filteredCredentials: StoredCredentials = {};
+
+        for (const { service, profile } of selectedProfiles) {
+          // Add to filtered config
+          if (!filteredConfig.profiles[service]) {
+            (filteredConfig.profiles as Record<string, string[]>)[service] = [];
+          }
+          (filteredConfig.profiles as Record<string, string[]>)[service].push(profile);
+
+          // Add credentials if they exist
+          if (credentials[service]?.[profile]) {
+            if (!filteredCredentials[service]) {
+              filteredCredentials[service] = {};
+            }
+            filteredCredentials[service][profile] = credentials[service][profile];
+          }
+        }
+
+        // Include env vars if they exist
+        if (configData.env) {
+          filteredConfig.env = configData.env;
+        }
+
         const exportData: ExportedData = {
           version: 1,
-          config: configData,
-          credentials,
+          config: filteredConfig,
+          credentials: filteredCredentials,
         };
 
         // Encrypt the data
         const key = deriveKeyFromPassword(encryptionKey);
         const encrypted = encrypt(JSON.stringify(exportData), key);
 
+        const profileCount = selectedProfiles.length;
+        const profileText = profileCount === 1 ? 'profile' : 'profiles';
+
         if (options.file) {
           // Write to file, output just the key
           const filePath = options.file.startsWith('/') ? options.file : join(process.cwd(), options.file);
           await writeFile(filePath, encrypted, { mode: 0o600 });
+          console.error(`Exported ${profileCount} ${profileText} to ${filePath}`);
           console.log(`AGENTIO_KEY=${encryptionKey}`);
         } else {
           // Output as environment variables
+          console.error(`Exported ${profileCount} ${profileText}`);
           console.log(`AGENTIO_KEY=${encryptionKey}`);
           console.log(`AGENTIO_CONFIG=${encrypted}`);
         }

package/src/commands/discourse.ts

@@ -25,7 +25,7 @@ export function registerDiscourseCommands(program: Command): void {
   discourse
     .command('list')
     .description('List latest topics')
-    .requiredOption('--profile <name>', 'Profile name')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
     .option('--category <slug>', 'Filter by category slug or name')
     .option('--page <number>', 'Page number (0-indexed)', '0')
     .action(async (options) => {
@@ -46,7 +46,7 @@ export function registerDiscourseCommands(program: Command): void {
     .command('get')
     .description('Get a topic with its posts')
     .argument('<topic-id>', 'Topic ID')
-    .requiredOption('--profile <name>', 'Profile name')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
     .action(async (topicId: string, options) => {
       try {
         const id = parseInt(topicId, 10);
@@ -66,7 +66,7 @@ export function registerDiscourseCommands(program: Command): void {
   discourse
     .command('categories')
     .description('List all categories')
-    .requiredOption('--profile <name>', 'Profile name')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
     .action(async (options) => {
       try {
         const { client } = await getDiscourseClient(options.profile);

package/src/commands/gchat.ts

@@ -10,6 +10,7 @@ import { createGoogleAuth } from '../auth/token-manager';
 import { GChatClient } from '../services/gchat/client';
 import { CliError, handleError } from '../utils/errors';
 import { readStdin, prompt } from '../utils/stdin';
+import { interactiveSelect } from '../utils/interactive';
 import { printGChatSendResult, printGChatMessageList, printGChatMessage, printGChatSpaceList } from '../utils/output';
 import type { GChatCredentials, GChatWebhookCredentials, GChatOAuthCredentials } from '../types/gchat';
 
@@ -26,7 +27,7 @@ export function registerGChatCommands(program: Command): void {
   gchat
     .command('send')
     .description('Send a message to Google Chat')
-    .requiredOption('--profile <name>', 'Profile name')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
     .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)')
@@ -111,7 +112,7 @@ export function registerGChatCommands(program: Command): void {
   gchat
     .command('list')
     .description('List messages from a Google Chat space (OAuth profiles only)')
-    .requiredOption('--profile <name>', 'Profile name')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
     .requiredOption('--space <id>', 'Space ID')
     .option('--limit <n>', 'Number of messages', '10')
     .option('--thread <id>', 'Filter by thread ID')
@@ -135,7 +136,7 @@ export function registerGChatCommands(program: Command): void {
   gchat
     .command('get <message-id>')
     .description('Get a message from a Google Chat space (OAuth profiles only)')
-    .requiredOption('--profile <name>', 'Profile name')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
     .requiredOption('--space <id>', 'Space ID')
     .action(async (messageId: string, options) => {
       try {
@@ -154,7 +155,7 @@ export function registerGChatCommands(program: Command): void {
   gchat
     .command('spaces')
     .description('List available Google Chat spaces (OAuth profiles only)')
-    .requiredOption('--profile <name>', 'Profile name')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
     .option('--filter <text>', 'Filter spaces by name (case-insensitive)')
     .action(async (options) => {
       try {
@@ -187,9 +188,15 @@ export function registerGChatCommands(program: Command): void {
       try {
         console.error('\nGoogle Chat Setup\n');
 
-        const profileType = await prompt('Choose profile type (webhook/oauth): ');
+        const profileType = await interactiveSelect({
+          message: 'Choose profile type:',
+          choices: [
+            { name: 'Webhook', value: 'webhook', description: 'Simple incoming webhook URL' },
+            { name: 'OAuth', value: 'oauth', description: 'Full API access with Google Workspace account' },
+          ],
+        });
 
-        if (profileType.toLowerCase() === 'webhook') {
+        if (profileType === 'webhook') {
           if (!options.profile) {
             throw new CliError(
               'INVALID_PARAMS',
@@ -198,10 +205,8 @@ export function registerGChatCommands(program: Command): void {
             );
           }
           await setupWebhookProfile(options.profile);
-        } else if (profileType.toLowerCase() === 'oauth') {
-          await setupOAuthProfile(options.profile);
         } else {
-          throw new CliError('INVALID_PARAMS', 'Profile type must be "webhook" or "oauth"');
+          await setupOAuthProfile(options.profile);
         }
       } catch (error) {
         handleError(error);

package/src/commands/gdocs.ts

@@ -0,0 +1,186 @@
+import { Command } from 'commander';
+import { writeFile } from 'fs/promises';
+import { google } from 'googleapis';
+import { createGoogleAuth } from '../auth/token-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 { GDocsClient } from '../services/gdocs/client';
+import { printGDocsList, printGDocCreated, raw } from '../utils/output';
+import { CliError, handleError } from '../utils/errors';
+import { readStdin } from '../utils/stdin';
+import type { GDocsCredentials } from '../types/gdocs';
+
+const getGDocsClient = createClientGetter<GDocsCredentials, GDocsClient>({
+  service: 'gdocs',
+  createClient: (credentials) => new GDocsClient(credentials),
+});
+
+export function registerGDocsCommands(program: Command): void {
+  const gdocs = program
+    .command('gdocs')
+    .description('Google Docs operations');
+
+  gdocs
+    .command('get <doc-id-or-url>')
+    .description('Export a document')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .option('--format <format>', 'Export format: markdown or docx', 'markdown')
+    .option('--output <file>', 'Output file path (required for docx, optional for markdown)')
+    .action(async (docIdOrUrl: string, options) => {
+      try {
+        const { client } = await getGDocsClient(options.profile);
+        const format = options.format.toLowerCase();
+
+        if (format !== 'markdown' && format !== 'docx') {
+          throw new CliError('INVALID_PARAMS', `Unknown format: ${format}`, 'Use --format markdown or --format docx');
+        }
+
+        if (format === 'docx' && !options.output) {
+          throw new CliError('INVALID_PARAMS', 'Output file required for docx format', 'Use --output <file.docx>');
+        }
+
+        const content = format === 'docx'
+          ? await client.getAsDocx(docIdOrUrl)
+          : await client.getAsMarkdown(docIdOrUrl);
+
+        if (options.output) {
+          await writeFile(options.output, content);
+          console.log(`Exported to ${options.output}`);
+        } else {
+          raw(content as string);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gdocs
+    .command('create')
+    .description('Create a new document from Markdown')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .requiredOption('--title <title>', 'Document title')
+    .option('--content <text>', 'Markdown content (or pipe via stdin)')
+    .option('--folder <folder-id>', 'Folder ID to create the document in')
+    .action(async (options) => {
+      try {
+        let content = options.content;
+
+        if (!content) {
+          content = await readStdin();
+        }
+
+        if (!content) {
+          throw new CliError('INVALID_PARAMS', 'No content provided', 'Provide --content or pipe markdown via stdin');
+        }
+
+        const { client } = await getGDocsClient(options.profile);
+        const result = await client.create(options.title, content, options.folder);
+
+        printGDocCreated(result);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gdocs
+    .command('list')
+    .description('List recent documents')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .option('--limit <n>', 'Number of documents', '10')
+    .option('--query <query>', 'Drive search query filter')
+    .addHelpText('after', `
+Query Syntax Examples:
+
+  Name search:
+    --query "name contains 'project'"     Documents with "project" in name
+    --query "name = 'Meeting Notes'"      Exact name match
+
+  Ownership:
+    --query "'me' in owners"              Documents you own
+    --query "'user@example.com' in owners"  Documents owned by specific user
+
+  Date filters:
+    --query "modifiedTime > '2024-01-01'"   Modified after date
+    --query "createdTime > '2024-01-01'"    Created after date
+
+  Starred/Trashed:
+    --query "starred = true"              Starred documents
+    --query "trashed = false"             Not in trash (default)
+
+  Combined:
+    --query "name contains 'report' and modifiedTime > '2024-01-01'"
+`)
+    .action(async (options) => {
+      try {
+        const { client } = await getGDocsClient(options.profile);
+        const docs = await client.list({
+          limit: parseInt(options.limit, 10),
+          query: options.query,
+        });
+        printGDocsList(docs);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Profile management
+  const profile = createProfileCommands<GDocsCredentials>(gdocs, {
+    service: 'gdocs',
+    displayName: 'Google Docs',
+    getExtraInfo: (credentials) => credentials?.email ? ` - ${credentials.email}` : '',
+  });
+
+  profile
+    .command('add')
+    .description('Add a new Google Docs profile')
+    .option('--profile <name>', 'Profile name (auto-detected from email if not provided)')
+    .action(async (options) => {
+      try {
+        console.error('Starting OAuth flow for Google Docs...\n');
+
+        const tokens = await performOAuthFlow('gdocs');
+        const auth = createGoogleAuth(tokens);
+
+        // 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'
+          );
+        }
+
+        const profileName = options.profile || userEmail;
+
+        const credentials: GDocsCredentials = {
+          accessToken: tokens.access_token,
+          refreshToken: tokens.refresh_token,
+          expiryDate: tokens.expiry_date,
+          tokenType: tokens.token_type,
+          scope: tokens.scope,
+          email: userEmail,
+        };
+
+        await setProfile('gdocs', profileName);
+        await setCredentials('gdocs', profileName, credentials);
+
+        console.log(`\nSuccess! Profile "${profileName}" configured.`);
+        console.log(`   Email: ${userEmail}`);
+        console.log(`   Test with: agentio gdocs list --profile ${profileName}`);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}