@plosson/agentio 0.4.2 → 0.4.4

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;