@plosson/agentio 0.4.2 → 0.4.4

package/src/commands/gsheets.ts

@@ -0,0 +1,365 @@
+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 { GSheetsClient } from '../services/gsheets/client';
+import {
+  printGSheetsList,
+  printGSheetsMetadata,
+  printGSheetsValues,
+  printGSheetsUpdateResult,
+  printGSheetsAppendResult,
+  printGSheetsClearResult,
+  printGSheetsCreated,
+} from '../utils/output';
+import { CliError, handleError } from '../utils/errors';
+import type { GSheetsCredentials } from '../types/gsheets';
+
+const getGSheetsClient = createClientGetter<GSheetsCredentials, GSheetsClient>({
+  service: 'gsheets',
+  createClient: (credentials) => new GSheetsClient(credentials),
+});
+
+/**
+ * Parse values from CLI arguments or JSON
+ * Supports two formats:
+ * - Simple: comma-separated rows, pipe-separated cells (e.g., "a|b|c,d|e|f")
+ * - JSON: 2D array (e.g., '[["a","b"],["c","d"]]')
+ */
+function parseValues(valueArgs: string[], valuesJson?: string): unknown[][] {
+  if (valuesJson) {
+    try {
+      const parsed = JSON.parse(valuesJson);
+      if (!Array.isArray(parsed)) {
+        throw new Error('JSON must be a 2D array');
+      }
+      return parsed;
+    } catch (err) {
+      throw new CliError('INVALID_PARAMS', `Invalid JSON values: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+
+  if (valueArgs.length === 0) {
+    throw new CliError('INVALID_PARAMS', 'No values provided', 'Provide values as args or via --values-json');
+  }
+
+  // Parse simple format: comma-separated rows, pipe-separated cells
+  const rawValues = valueArgs.join(' ');
+  const rows = rawValues.split(',');
+  return rows.map((row) => {
+    const cells = row.trim().split('|');
+    return cells.map((cell) => cell.trim());
+  });
+}
+
+export function registerGSheetsCommands(program: Command): void {
+  const gsheets = program.command('gsheets').description('Google Sheets operations');
+
+  gsheets
+    .command('list')
+    .description('List recent spreadsheets')
+    .option('--profile <name>', 'Profile name')
+    .option('--limit <n>', 'Number of spreadsheets', '10')
+    .option('--query <query>', 'Drive search query filter')
+    .addHelpText(
+      'after',
+      `
+Query Syntax Examples:
+
+  Name search:
+    --query "name contains 'budget'"      Spreadsheets with "budget" in name
+    --query "name = 'Q1 Report'"          Exact name match
+
+  Ownership:
+    --query "'me' in owners"              Spreadsheets you own
+    --query "'user@example.com' in owners"
+
+  Date filters:
+    --query "modifiedTime > '2024-01-01'" Modified after date
+    --query "createdTime > '2024-01-01'"  Created after date
+
+  Combined:
+    --query "name contains 'sales' and modifiedTime > '2024-01-01'"
+`
+    )
+    .action(async (options) => {
+      try {
+        const { client } = await getGSheetsClient(options.profile);
+        const spreadsheets = await client.list({
+          limit: parseInt(options.limit, 10),
+          query: options.query,
+        });
+        printGSheetsList(spreadsheets);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gsheets
+    .command('get')
+    .argument('<spreadsheet-id-or-url>', 'Spreadsheet ID or URL')
+    .argument('<range>', 'Range in A1 notation (e.g., Sheet1!A1:B10)')
+    .description('Get values from a range')
+    .option('--profile <name>', 'Profile name')
+    .option('--dimension <dim>', 'Major dimension: ROWS or COLUMNS')
+    .option('--render <opt>', 'Value render: FORMATTED_VALUE, UNFORMATTED_VALUE, or FORMULA')
+    .action(async (spreadsheetId: string, range: string, options) => {
+      try {
+        const { client } = await getGSheetsClient(options.profile);
+        const result = await client.get(spreadsheetId, range, {
+          majorDimension: options.dimension,
+          valueRenderOption: options.render,
+        });
+        printGSheetsValues(result);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gsheets
+    .command('update')
+    .argument('<spreadsheet-id-or-url>', 'Spreadsheet ID or URL')
+    .argument('<range>', 'Range in A1 notation (e.g., Sheet1!A1:B2)')
+    .argument('[values...]', 'Values (comma-separated rows, pipe-separated cells)')
+    .description('Update values in a range')
+    .option('--profile <name>', 'Profile name')
+    .option('--values-json <json>', 'Values as JSON 2D array')
+    .option('--input <opt>', 'Value input option: RAW or USER_ENTERED', 'USER_ENTERED')
+    .addHelpText(
+      'after',
+      `
+Value Formats:
+
+  Simple format (comma = row separator, pipe = cell separator):
+    agentio gsheets update <id> Sheet1!A1:B2 "a|b,c|d"
+    Results in:
+      A1=a  B1=b
+      A2=c  B2=d
+
+  JSON format:
+    agentio gsheets update <id> Sheet1!A1:B2 --values-json '[["a","b"],["c","d"]]'
+
+Input Options:
+  RAW          - Values are stored exactly as entered (no parsing)
+  USER_ENTERED - Values are parsed as if typed in the UI (formulas, dates, etc.)
+`
+    )
+    .action(async (spreadsheetId: string, range: string, valueArgs: string[], options) => {
+      try {
+        const values = parseValues(valueArgs, options.valuesJson);
+        const { client } = await getGSheetsClient(options.profile);
+        const result = await client.update(spreadsheetId, range, values, {
+          valueInputOption: options.input,
+        });
+        printGSheetsUpdateResult(result);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gsheets
+    .command('append')
+    .argument('<spreadsheet-id-or-url>', 'Spreadsheet ID or URL')
+    .argument('<range>', 'Range in A1 notation (e.g., Sheet1!A:C)')
+    .argument('[values...]', 'Values (comma-separated rows, pipe-separated cells)')
+    .description('Append values to a range')
+    .option('--profile <name>', 'Profile name')
+    .option('--values-json <json>', 'Values as JSON 2D array')
+    .option('--input <opt>', 'Value input option: RAW or USER_ENTERED', 'USER_ENTERED')
+    .option('--insert <opt>', 'Insert data option: OVERWRITE or INSERT_ROWS')
+    .addHelpText(
+      'after',
+      `
+Value Formats:
+
+  Simple format (comma = row separator, pipe = cell separator):
+    agentio gsheets append <id> Sheet1!A:C "a|b|c,d|e|f"
+    Appends two rows to columns A, B, C
+
+  JSON format:
+    agentio gsheets append <id> Sheet1!A:C --values-json '[["a","b","c"],["d","e","f"]]'
+
+Insert Options:
+  OVERWRITE   - New data overwrites existing data in the areas it is written
+  INSERT_ROWS - Rows are inserted for the new data
+`
+    )
+    .action(async (spreadsheetId: string, range: string, valueArgs: string[], options) => {
+      try {
+        const values = parseValues(valueArgs, options.valuesJson);
+        const { client } = await getGSheetsClient(options.profile);
+        const result = await client.append(spreadsheetId, range, values, {
+          valueInputOption: options.input,
+          insertDataOption: options.insert,
+        });
+        printGSheetsAppendResult(result);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gsheets
+    .command('clear')
+    .argument('<spreadsheet-id-or-url>', 'Spreadsheet ID or URL')
+    .argument('<range>', 'Range in A1 notation (e.g., Sheet1!A1:B10)')
+    .description('Clear values in a range')
+    .option('--profile <name>', 'Profile name')
+    .action(async (spreadsheetId: string, range: string, options) => {
+      try {
+        const { client } = await getGSheetsClient(options.profile);
+        const result = await client.clear(spreadsheetId, range);
+        printGSheetsClearResult(result);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gsheets
+    .command('metadata')
+    .argument('<spreadsheet-id-or-url>', 'Spreadsheet ID or URL')
+    .description('Get spreadsheet metadata')
+    .option('--profile <name>', 'Profile name')
+    .action(async (spreadsheetId: string, options) => {
+      try {
+        const { client } = await getGSheetsClient(options.profile);
+        const metadata = await client.metadata(spreadsheetId);
+        printGSheetsMetadata(metadata);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gsheets
+    .command('create')
+    .argument('<title>', 'Spreadsheet title')
+    .description('Create a new spreadsheet')
+    .option('--profile <name>', 'Profile name')
+    .option('--sheets <names>', 'Comma-separated sheet names to create')
+    .action(async (title: string, options) => {
+      try {
+        const { client } = await getGSheetsClient(options.profile);
+        const sheetNames = options.sheets ? options.sheets.split(',').map((n: string) => n.trim()) : undefined;
+        const result = await client.create(title, sheetNames);
+        printGSheetsCreated(result);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gsheets
+    .command('copy')
+    .argument('<spreadsheet-id-or-url>', 'Spreadsheet ID or URL')
+    .argument('<title>', 'New spreadsheet title')
+    .description('Copy a spreadsheet')
+    .option('--profile <name>', 'Profile name')
+    .option('--parent <folder-id>', 'Destination folder ID')
+    .action(async (spreadsheetId: string, title: string, options) => {
+      try {
+        const { client } = await getGSheetsClient(options.profile);
+        const result = await client.copy(spreadsheetId, title, options.parent);
+        printGSheetsCreated(result);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gsheets
+    .command('export')
+    .argument('<spreadsheet-id-or-url>', 'Spreadsheet ID or URL')
+    .description('Export a spreadsheet to a file')
+    .option('--profile <name>', 'Profile name')
+    .requiredOption('--output <path>', 'Output file path')
+    .option('--format <fmt>', 'Export format: xlsx, pdf, csv, ods, tsv', 'xlsx')
+    .addHelpText(
+      'after',
+      `
+Export Formats:
+  xlsx - Microsoft Excel (default)
+  pdf  - PDF document
+  csv  - Comma-separated values (first sheet only)
+  ods  - OpenDocument Spreadsheet
+  tsv  - Tab-separated values (first sheet only)
+
+Examples:
+  agentio gsheets export <id> --output report.xlsx
+  agentio gsheets export <id> --output data.csv --format csv
+`
+    )
+    .action(async (spreadsheetId: string, options) => {
+      try {
+        const { client } = await getGSheetsClient(options.profile);
+        const format = options.format.toLowerCase();
+
+        if (!['xlsx', 'pdf', 'csv', 'ods', 'tsv'].includes(format)) {
+          throw new CliError('INVALID_PARAMS', `Unknown format: ${format}`, 'Use xlsx, pdf, csv, ods, or tsv');
+        }
+
+        const result = await client.export(spreadsheetId, format as 'xlsx' | 'pdf' | 'csv' | 'ods' | 'tsv');
+        await writeFile(options.output, result.data);
+        console.log(`Exported to ${options.output}`);
+        console.log(`  Format: ${format}`);
+        console.log(`  Size: ${result.data.length} bytes`);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Profile management
+  const profile = createProfileCommands<GSheetsCredentials>(gsheets, {
+    service: 'gsheets',
+    displayName: 'Google Sheets',
+    getExtraInfo: (credentials) => (credentials?.email ? ` - ${credentials.email}` : ''),
+  });
+
+  profile
+    .command('add')
+    .description('Add a new Google Sheets profile')
+    .option('--profile <name>', 'Profile name (auto-detected from email if not provided)')
+    .action(async (options) => {
+      try {
+        console.error('Starting OAuth flow for Google Sheets...\n');
+
+        const tokens = await performOAuthFlow('gsheets');
+        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: GSheetsCredentials = {
+          accessToken: tokens.access_token,
+          refreshToken: tokens.refresh_token,
+          expiryDate: tokens.expiry_date,
+          tokenType: tokens.token_type,
+          scope: tokens.scope,
+          email: userEmail,
+        };
+
+        await setProfile('gsheets', profileName);
+        await setCredentials('gsheets', profileName, credentials);
+
+        console.log(`\nSuccess! Profile "${profileName}" configured.`);
+        console.log(`   Email: ${userEmail}`);
+        console.log(`   Test with: agentio gsheets list --profile ${profileName}`);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/commands/gtasks.ts

@@ -0,0 +1,326 @@
+import { Command } from 'commander';
+import { google } from 'googleapis';
+import { getValidTokens, createGoogleAuth } from '../auth/token-manager';
+import { setCredentials } from '../auth/token-store';
+import { setProfile } from '../config/config-manager';
+import { createProfileCommands } from '../utils/profile-commands';
+import { performOAuthFlow } from '../auth/oauth';
+import { GTasksClient } from '../services/gtasks/client';
+import {
+  printGTasksList,
+  printGTaskList,
+  printGTaskListCreated,
+  printGTaskListDeleted,
+  printGTasks,
+  printGTask,
+  printGTaskCreated,
+  printGTaskDeleted,
+  printGTasksCleared,
+} from '../utils/output';
+import { CliError, handleError } from '../utils/errors';
+import { readStdin } from '../utils/stdin';
+
+async function getGTasksClient(profileName?: string): Promise<{ client: GTasksClient; profile: string }> {
+  const { tokens, profile } = await getValidTokens('gtasks', profileName);
+  const auth = createGoogleAuth(tokens);
+  return { client: new GTasksClient(auth), profile };
+}
+
+export function registerGTasksCommands(program: Command): void {
+  const gtasks = program
+    .command('gtasks')
+    .description('Google Tasks operations');
+
+  // === Task Lists Commands ===
+
+  const lists = gtasks
+    .command('lists')
+    .description('Manage task lists');
+
+  // List task lists (default subcommand)
+  lists
+    .command('list', { isDefault: true })
+    .description('List all task lists')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .option('--limit <n>', 'Max results', '100')
+    .action(async (options) => {
+      try {
+        const { client } = await getGTasksClient(options.profile);
+        const result = await client.listTaskLists(parseInt(options.limit, 10));
+        printGTasksList(result.taskLists, result.nextPageToken);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Create task list
+  lists
+    .command('create <title>')
+    .description('Create a new task list')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .action(async (title: string, options) => {
+      try {
+        const { client } = await getGTasksClient(options.profile);
+        const taskList = await client.createTaskList(title);
+        printGTaskListCreated(taskList);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Delete task list
+  lists
+    .command('delete <tasklist-id>')
+    .description('Delete a task list')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .action(async (tasklistId: string, options) => {
+      try {
+        const { client } = await getGTasksClient(options.profile);
+        await client.deleteTaskList(tasklistId);
+        printGTaskListDeleted(tasklistId);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // === Task Commands ===
+
+  // List tasks in a task list
+  gtasks
+    .command('list <tasklist-id>')
+    .description('List tasks in a task list')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .option('--limit <n>', 'Max results', '20')
+    .option('--show-completed', 'Include completed tasks', true)
+    .option('--no-show-completed', 'Exclude completed tasks')
+    .option('--show-hidden', 'Include hidden tasks')
+    .option('--due-min <datetime>', 'Filter: due date minimum (RFC3339)')
+    .option('--due-max <datetime>', 'Filter: due date maximum (RFC3339)')
+    .action(async (tasklistId: string, options) => {
+      try {
+        const { client } = await getGTasksClient(options.profile);
+        const result = await client.listTasks({
+          tasklistId,
+          maxResults: parseInt(options.limit, 10),
+          showCompleted: options.showCompleted,
+          showHidden: options.showHidden,
+          dueMin: options.dueMin,
+          dueMax: options.dueMax,
+        });
+        printGTasks(result.tasks, result.nextPageToken);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Get a specific task
+  gtasks
+    .command('get <tasklist-id> <task-id>')
+    .description('Get a specific task')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .action(async (tasklistId: string, taskId: string, options) => {
+      try {
+        const { client } = await getGTasksClient(options.profile);
+        const task = await client.getTask(tasklistId, taskId);
+        printGTask(task);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Add a new task
+  gtasks
+    .command('add <tasklist-id>')
+    .description('Add a new task')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .requiredOption('--title <title>', 'Task title')
+    .option('--notes <text>', 'Task notes/description (or pipe via stdin)')
+    .option('--due <date>', 'Due date (RFC3339 or YYYY-MM-DD)')
+    .option('--parent <task-id>', 'Parent task ID (create as subtask)')
+    .option('--previous <task-id>', 'Previous sibling task ID (controls ordering)')
+    .action(async (tasklistId: string, options) => {
+      try {
+        let notes = options.notes;
+        if (!notes) {
+          const stdin = await readStdin();
+          if (stdin) notes = stdin;
+        }
+
+        const { client } = await getGTasksClient(options.profile);
+        const task = await client.createTask({
+          tasklistId,
+          title: options.title,
+          notes,
+          due: options.due,
+          parent: options.parent,
+          previous: options.previous,
+        });
+        printGTaskCreated(task);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Update a task
+  gtasks
+    .command('update <tasklist-id> <task-id>')
+    .description('Update an existing task')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .option('--title <title>', 'New title')
+    .option('--notes <text>', 'New notes (or pipe via stdin)')
+    .option('--due <date>', 'New due date (RFC3339 or YYYY-MM-DD, empty to clear)')
+    .option('--status <status>', 'New status: needsAction or completed')
+    .action(async (tasklistId: string, taskId: string, options) => {
+      try {
+        let notes = options.notes;
+        if (notes === undefined && !process.stdin.isTTY) {
+          const stdin = await readStdin();
+          if (stdin) notes = stdin;
+        }
+
+        if (options.status && !['needsAction', 'completed'].includes(options.status)) {
+          throw new CliError('INVALID_PARAMS', `Invalid status: ${options.status}`, 'Use: needsAction or completed');
+        }
+
+        const { client } = await getGTasksClient(options.profile);
+        const task = await client.updateTask({
+          tasklistId,
+          taskId,
+          title: options.title,
+          notes,
+          due: options.due,
+          status: options.status,
+        });
+        printGTask(task);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Mark task as done
+  gtasks
+    .command('done <tasklist-id> <task-id>')
+    .alias('complete')
+    .description('Mark a task as completed')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .action(async (tasklistId: string, taskId: string, options) => {
+      try {
+        const { client } = await getGTasksClient(options.profile);
+        const task = await client.completeTask(tasklistId, taskId);
+        console.log(`Task completed: ${task.title}`);
+        console.log(`ID: ${task.id}`);
+        console.log(`Status: ${task.status}`);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Mark task as not done
+  gtasks
+    .command('undo <tasklist-id> <task-id>')
+    .alias('uncomplete')
+    .description('Mark a task as needs action (not completed)')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .action(async (tasklistId: string, taskId: string, options) => {
+      try {
+        const { client } = await getGTasksClient(options.profile);
+        const task = await client.uncompleteTask(tasklistId, taskId);
+        console.log(`Task uncompleted: ${task.title}`);
+        console.log(`ID: ${task.id}`);
+        console.log(`Status: ${task.status}`);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Delete a task
+  gtasks
+    .command('delete <tasklist-id> <task-id>')
+    .description('Delete a task')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .action(async (tasklistId: string, taskId: string, options) => {
+      try {
+        const { client } = await getGTasksClient(options.profile);
+        await client.deleteTask(tasklistId, taskId);
+        printGTaskDeleted(tasklistId, taskId);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Clear completed tasks
+  gtasks
+    .command('clear <tasklist-id>')
+    .description('Clear all completed tasks from a task list')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .action(async (tasklistId: string, options) => {
+      try {
+        const { client } = await getGTasksClient(options.profile);
+        await client.clearCompleted(tasklistId);
+        printGTasksCleared(tasklistId);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Move a task
+  gtasks
+    .command('move <tasklist-id> <task-id>')
+    .description('Move a task (change parent or position)')
+    .option('--profile <name>', 'Profile name (optional if only one profile exists)')
+    .option('--parent <task-id>', 'New parent task ID (make subtask)')
+    .option('--previous <task-id>', 'Previous sibling task ID (change position)')
+    .action(async (tasklistId: string, taskId: string, options) => {
+      try {
+        if (!options.parent && !options.previous) {
+          throw new CliError('INVALID_PARAMS', 'At least one of --parent or --previous is required');
+        }
+        const { client } = await getGTasksClient(options.profile);
+        const task = await client.moveTask(tasklistId, taskId, options.parent, options.previous);
+        console.log(`Task moved: ${task.title}`);
+        console.log(`ID: ${task.id}`);
+        if (task.parent) console.log(`Parent: ${task.parent}`);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Profile management
+  const profile = createProfileCommands<{ email?: string }>(gtasks, {
+    service: 'gtasks',
+    displayName: 'Google Tasks',
+    getExtraInfo: (credentials) => credentials?.email ? ` - ${credentials.email}` : '',
+  });
+
+  profile
+    .command('add')
+    .description('Add a new Google Tasks profile')
+    .option('--profile <name>', 'Profile name (auto-detected from email if not provided)')
+    .action(async (options) => {
+      try {
+        console.error('Starting OAuth flow for Google Tasks...\n');
+
+        const tokens = await performOAuthFlow('gtasks');
+
+        // Fetch user email via oauth2 userinfo
+        const auth = createGoogleAuth(tokens);
+        const oauth2 = google.oauth2({ version: 'v2', auth });
+        const userInfo = await oauth2.userinfo.get();
+        const email = userInfo.data.email;
+
+        if (!email) {
+          throw new CliError('AUTH_FAILED', 'Could not fetch email', 'Try again or specify --profile manually');
+        }
+
+        const profileName = options.profile || email;
+
+        await setProfile('gtasks', profileName);
+        await setCredentials('gtasks', profileName, { ...tokens, email });
+
+        console.log(`\nSuccess! Profile "${profileName}" configured.`);
+        console.log(`   Email: ${email}`);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}