@plosson/agentio 0.4.2 → 0.4.3

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

package/src/commands/status.ts

@@ -7,6 +7,8 @@ import { TelegramClient } from '../services/telegram/client';
 import { GmailClient } from '../services/gmail/client';
 import { GDocsClient } from '../services/gdocs/client';
 import { GDriveClient } from '../services/gdrive/client';
+import { GCalClient } from '../services/gcal/client';
+import { GTasksClient } from '../services/gtasks/client';
 import { GitHubClient } from '../services/github/client';
 import { JiraClient } from '../services/jira/client';
 import { GChatClient } from '../services/gchat/client';
@@ -21,10 +23,14 @@ import type { GitHubCredentials } from '../types/github';
 import type { JiraCredentials } from '../types/jira';
 import type { GDocsCredentials } from '../types/gdocs';
 import type { GDriveCredentials } from '../types/gdrive';
+import type { GCalCredentials } from '../types/gcal';
+import type { GTasksCredentials } from '../types/gtasks';
 import type { GChatCredentials } from '../types/gchat';
 import type { SlackCredentials } from '../types/slack';
 import type { DiscourseCredentials } from '../types/discourse';
 import type { SqlCredentials } from '../types/sql';
+import type { WhatsAppCredentials } from '../types/whatsapp';
+import { isGatewayAvailable, getGatewayClient } from '../gateway/client';
 
 type GmailCredentials = OAuthTokens & { email?: string };
 
@@ -60,6 +66,30 @@ async function createServiceClient(
       return new GDriveClient(creds);
     }
 
+    case 'gcal': {
+      const creds = credentials as GCalCredentials;
+      const auth = createGoogleAuth({
+        access_token: creds.access_token,
+        refresh_token: creds.refresh_token,
+        expiry_date: creds.expiry_date,
+        token_type: creds.token_type || 'Bearer',
+        scope: creds.scope,
+      });
+      return new GCalClient(auth);
+    }
+
+    case 'gtasks': {
+      const creds = credentials as GTasksCredentials;
+      const auth = createGoogleAuth({
+        access_token: creds.access_token,
+        refresh_token: creds.refresh_token,
+        expiry_date: creds.expiry_date,
+        token_type: creds.token_type || 'Bearer',
+        scope: creds.scope,
+      });
+      return new GTasksClient(auth);
+    }
+
     case 'telegram': {
       const creds = credentials as TelegramCredentials;
       return new TelegramClient(creds.botToken, creds.channelId);
@@ -150,6 +180,61 @@ async function createServiceClient(
       return new SqlClient(creds);
     }
 
+    case 'whatsapp': {
+      const creds = credentials as WhatsAppCredentials;
+      return {
+        validate: async (): Promise<ValidationResult> => {
+          // Check if gateway is running
+          const gatewayAvailable = await isGatewayAvailable();
+          if (!gatewayAvailable) {
+            if (creds.paired) {
+              return {
+                valid: true,
+                info: `${creds.phoneNumber || 'paired'} (gateway not running)`,
+              };
+            }
+            return { valid: false, error: 'not paired (gateway not running)' };
+          }
+
+          // Check connection status via gateway - this is the source of truth
+          try {
+            const client = await getGatewayClient();
+            const status = await client.status();
+            const adapter = status.adapters.find(
+              (a) => a.service === 'whatsapp' && a.profile === profileName
+            );
+
+            if (adapter?.connected) {
+              // Connected via gateway = working
+              return { valid: true, info: creds.phoneNumber || 'connected' };
+            } else if (adapter) {
+              // Adapter exists but not connected
+              return {
+                valid: true,
+                info: `${creds.phoneNumber || 'configured'} (disconnected)`,
+              };
+            } else if (creds.paired) {
+              // Has paired credentials but no adapter in gateway
+              return {
+                valid: true,
+                info: `${creds.phoneNumber || 'paired'} (not loaded in gateway)`,
+              };
+            } else {
+              return { valid: false, error: 'not paired' };
+            }
+          } catch {
+            if (creds.paired) {
+              return {
+                valid: true,
+                info: `${creds.phoneNumber || 'paired'} (gateway error)`,
+              };
+            }
+            return { valid: false, error: 'gateway error' };
+          }
+        },
+      };
+    }
+
     default:
       return null;
   }

package/src/commands/telegram.ts

@@ -1,11 +1,22 @@
 import { Command } from 'commander';
 import { setCredentials } from '../auth/token-store';
-import { setProfile } from '../config/config-manager';
+import { setProfile, resolveProfile } from '../config/config-manager';
 import { createProfileCommands } from '../utils/profile-commands';
 import { createClientGetter } from '../utils/client-factory';
 import { TelegramClient } from '../services/telegram/client';
 import { CliError, handleError } from '../utils/errors';
 import { readStdin, prompt } from '../utils/stdin';
+import { getGatewayClient, isGatewayAvailable } from '../gateway/client';
+import {
+  printInboxMessageList,
+  printInboxMessage,
+  printInboxStats,
+  printInboxAckResult,
+  printInboxReplyResult,
+  printOutboxMessageList,
+  printOutboxMessage,
+  printOutboxSendResult,
+} from '../utils/output';
 import type { TelegramCredentials, TelegramSendOptions } from '../types/telegram';
 
 const getTelegramClient = createClientGetter<TelegramCredentials, TelegramClient>({
@@ -169,4 +180,201 @@ export function registerTelegramCommands(program: Command): void {
         handleError(error);
       }
     });
+
+  // Inbox subcommands (requires gateway)
+  const inbox = telegram.command('inbox').description('Inbox operations (requires gateway)');
+
+  inbox
+    .command('pull')
+    .description('Get pending messages from inbox')
+    .option('--profile <name>', 'Profile name')
+    .option('--limit <n>', 'Maximum messages to retrieve', '50')
+    .option('--status <status>', 'Filter by status: pending or done', 'pending')
+    .action(async (options) => {
+      try {
+        const profileResult = await resolveProfile('telegram', options.profile);
+        if (!profileResult.profile) {
+          if (profileResult.error === 'none') {
+            throw new CliError('PROFILE_NOT_FOUND', 'No Telegram profiles configured', 'Run: agentio telegram profile add');
+          }
+          throw new CliError('INVALID_PARAMS', 'Multiple profiles exist. Use --profile to specify one.');
+        }
+
+        const client = await getGatewayClient();
+        const messages = await client.inboxPull({
+          service: 'telegram',
+          profile: profileResult.profile,
+          limit: parseInt(options.limit, 10),
+          status: options.status as 'pending' | 'done',
+        });
+        printInboxMessageList(messages);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  inbox
+    .command('get')
+    .description('Get a specific inbox message')
+    .argument('<id>', 'Message ID')
+    .action(async (id: string) => {
+      try {
+        const client = await getGatewayClient();
+        const message = await client.inboxGet(id);
+        if (!message) {
+          throw new CliError('NOT_FOUND', `Message not found: ${id}`);
+        }
+        printInboxMessage(message);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  inbox
+    .command('ack')
+    .description('Mark a message as done')
+    .argument('<id>', 'Message ID')
+    .action(async (id: string) => {
+      try {
+        const client = await getGatewayClient();
+        const success = await client.inboxAck(id);
+        printInboxAckResult(success, id);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  inbox
+    .command('reply')
+    .description('Reply to an inbox message')
+    .argument('<id>', 'Message ID to reply to')
+    .argument('[message]', 'Reply text (or pipe via stdin)')
+    .action(async (id: string, message: string | undefined) => {
+      try {
+        let text = message;
+        if (!text) {
+          text = await readStdin() || undefined;
+        }
+        if (!text) {
+          throw new CliError('INVALID_PARAMS', 'Message is required. Provide as argument or pipe via stdin.');
+        }
+
+        const client = await getGatewayClient();
+        const result = await client.inboxReply(id, text);
+        printInboxReplyResult(result);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  inbox
+    .command('stats')
+    .description('Get inbox statistics')
+    .option('--profile <name>', 'Profile name')
+    .action(async (options) => {
+      try {
+        const profileResult = await resolveProfile('telegram', options.profile);
+        const client = await getGatewayClient();
+        const stats = await client.inboxStats({
+          service: 'telegram',
+          profile: profileResult.profile ?? undefined,
+        });
+        printInboxStats(stats);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Outbox subcommands (requires gateway)
+  const outbox = telegram.command('outbox').description('Outbox operations (requires gateway)');
+
+  outbox
+    .command('send')
+    .description('Queue a message for sending')
+    .option('--profile <name>', 'Profile name')
+    .option('--to <chat-id>', 'Destination chat ID (required)')
+    .option('--parse-mode <mode>', 'Message format: html or markdown')
+    .argument('[message]', 'Message text (or pipe via stdin)')
+    .action(async (message: string | undefined, options) => {
+      try {
+        const profileResult = await resolveProfile('telegram', options.profile);
+        if (!profileResult.profile) {
+          if (profileResult.error === 'none') {
+            throw new CliError('PROFILE_NOT_FOUND', 'No Telegram profiles configured', 'Run: agentio telegram profile add');
+          }
+          throw new CliError('INVALID_PARAMS', 'Multiple profiles exist. Use --profile to specify one.');
+        }
+
+        if (!options.to) {
+          throw new CliError('INVALID_PARAMS', 'Destination chat ID is required. Use --to <chat-id>');
+        }
+
+        let text = message;
+        if (!text) {
+          text = await readStdin() || undefined;
+        }
+        if (!text) {
+          throw new CliError('INVALID_PARAMS', 'Message is required. Provide as argument or pipe via stdin.');
+        }
+
+        const metadata: Record<string, unknown> = {};
+        if (options.parseMode) {
+          const mode = options.parseMode.toLowerCase();
+          if (mode === 'html') metadata.parse_mode = 'HTML';
+          else if (mode === 'markdown') metadata.parse_mode = 'MarkdownV2';
+          else throw new CliError('INVALID_PARAMS', 'parse-mode must be "html" or "markdown"');
+        }
+
+        const client = await getGatewayClient();
+        const result = await client.outboxSend({
+          service: 'telegram',
+          profile: profileResult.profile,
+          conversationId: options.to,
+          content: text,
+          metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        });
+        printOutboxSendResult(result);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  outbox
+    .command('status')
+    .description('Check send status of a message')
+    .argument('<id>', 'Outbox message ID')
+    .action(async (id: string) => {
+      try {
+        const client = await getGatewayClient();
+        const message = await client.outboxStatus(id);
+        if (!message) {
+          throw new CliError('NOT_FOUND', `Message not found: ${id}`);
+        }
+        printOutboxMessage(message);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  outbox
+    .command('list')
+    .description('List outbox messages')
+    .option('--profile <name>', 'Profile name')
+    .option('--status <status>', 'Filter by status: pending, sending, sent, or failed')
+    .option('--limit <n>', 'Maximum messages to retrieve', '50')
+    .action(async (options) => {
+      try {
+        const profileResult = await resolveProfile('telegram', options.profile);
+        const client = await getGatewayClient();
+        const messages = await client.outboxList({
+          service: 'telegram',
+          profile: profileResult.profile ?? undefined,
+          status: options.status as 'pending' | 'sending' | 'sent' | 'failed' | undefined,
+          limit: parseInt(options.limit, 10),
+        });
+        printOutboxMessageList(messages);
+      } catch (error) {
+        handleError(error);
+      }
+    });
 }

package/src/commands/update.ts

@@ -275,9 +275,9 @@ export function registerUpdateCommand(program: Command): void {
           console.error('Automatic update failed. You can update manually:');
           console.error('');
           if (os.platform() === 'win32') {
-            console.error('  iwr -useb https://agentio.work/install.ps1 | iex');
+            console.error('  iwr -useb https://agentio.me/install.ps1 | iex');
           } else {
-            console.error('  curl -LsSf https://agentio.work/install | sh');
+            console.error('  curl -LsSf https://agentio.me/install | sh');
           }
           console.error('');
           throw error;