@plosson/agentio 0.1.0

package/src/commands/gmail.ts

@@ -0,0 +1,303 @@
+import { Command } from 'commander';
+import { basename } from 'path';
+import { getValidTokens, createGoogleAuth } from '../auth/token-manager';
+import { setCredentials, removeCredentials } from '../auth/token-store';
+import { setProfile, removeProfile, listProfiles } from '../config/config-manager';
+import { performOAuthFlow } from '../auth/oauth';
+import { GmailClient } from '../services/gmail/client';
+import { printMessageList, printMessage, printSendResult, printArchived, printMarked, raw } from '../utils/output';
+import { CliError, handleError } from '../utils/errors';
+import { readStdin } from '../utils/stdin';
+import type { GmailAttachment } from '../types/gmail';
+
+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 };
+}
+
+export function registerGmailCommands(program: Command): void {
+  const gmail = program
+    .command('gmail')
+    .description('Gmail operations');
+
+  gmail
+    .command('list')
+    .description('List messages')
+    .option('--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], [])
+    .action(async (options) => {
+      try {
+        const { client } = await getGmailClient(options.profile);
+        const result = await client.list({
+          limit: parseInt(options.limit, 10),
+          query: options.query,
+          labels: options.label.length ? options.label : undefined,
+        });
+        printMessageList(result.messages, result.total);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gmail
+    .command('get <message-id>')
+    .description('Get a message')
+    .option('--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) => {
+      try {
+        const { client } = await getGmailClient(options.profile);
+        const result = await client.get(messageId, options.format);
+        if (options.bodyOnly) {
+          raw(result.body);
+        } else {
+          printMessage(result);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gmail
+    .command('search')
+    .description('Search messages using Gmail query syntax')
+    .requiredOption('--query <query>', 'Search query')
+    .option('--profile <name>', 'Profile name')
+    .option('--limit <n>', 'Max results', '10')
+    .addHelpText('after', `
+Query Syntax Examples:
+
+  Keywords:
+    --query "meeting agenda"          Messages containing both words
+    --query "exact phrase"            Messages with exact phrase
+
+  From/To:
+    --query "from:john@example.com"   Messages from specific sender
+    --query "to:me"                   Messages sent to you
+    --query "from:john to:jane"       Combine sender and recipient
+    --query "cc:team@example.com"     Messages where someone was CC'd
+
+  Date Ranges:
+    --query "after:2024/01/01"        Messages after date (YYYY/MM/DD)
+    --query "before:2024/12/31"       Messages before date
+    --query "after:2024/01/01 before:2024/06/30"   Date range
+    --query "newer_than:7d"           Last 7 days (d=days, m=months, y=years)
+    --query "older_than:1m"           Older than 1 month
+
+  Labels:
+    --query "label:inbox"             Messages in inbox
+    --query "label:important"         Important messages
+    --query "label:work"              Custom label (use exact label name)
+    --query "-label:spam"             Exclude spam (- negates)
+
+  Status:
+    --query "is:unread"               Unread messages
+    --query "is:starred"              Starred messages
+    --query "is:important"            Marked as important
+    --query "has:attachment"          Messages with attachments
+
+  Subject:
+    --query "subject:invoice"         Search in subject only
+
+  Combined:
+    --query "from:boss@work.com is:unread newer_than:7d"
+    --query "has:attachment from:client after:2024/01/01"
+`)
+    .action(async (options) => {
+      try {
+        const { client } = await getGmailClient(options.profile);
+        const result = await client.search(options.query, parseInt(options.limit, 10));
+        printMessageList(result.messages, result.total);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gmail
+    .command('send')
+    .description('Send an email')
+    .option('--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], [])
+    .requiredOption('--subject <subject>', 'Email subject')
+    .option('--body <body>', 'Email body (or pipe via stdin)')
+    .option('--html', 'Treat body as HTML')
+    .option('--attachment <path>', 'File to attach (repeatable)', (val, acc: string[]) => [...acc, val], [])
+    .action(async (options) => {
+      try {
+        let body = options.body;
+
+        // Check for stdin if no body provided
+        if (!body) {
+          body = await readStdin();
+        }
+
+        if (!body) {
+          throw new CliError('INVALID_PARAMS', 'Body is required. Use --body or pipe via stdin.');
+        }
+
+        // Process attachments
+        const attachments: GmailAttachment[] | undefined = options.attachment.length
+          ? options.attachment.map((path: string) => ({
+              path,
+              filename: basename(path),
+            }))
+          : undefined;
+
+        const { client } = await getGmailClient(options.profile);
+        const result = await client.send({
+          to: options.to,
+          cc: options.cc.length ? options.cc : undefined,
+          bcc: options.bcc.length ? options.bcc : undefined,
+          subject: options.subject,
+          body,
+          isHtml: options.html,
+          attachments,
+        });
+        printSendResult(result);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gmail
+    .command('reply')
+    .description('Reply to a thread')
+    .option('--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')
+    .action(async (options) => {
+      try {
+        let body = options.body;
+
+        if (!body) {
+          body = await readStdin();
+        }
+
+        if (!body) {
+          throw new CliError('INVALID_PARAMS', 'Body is required. Use --body or pipe via stdin.');
+        }
+
+        const { client } = await getGmailClient(options.profile);
+        const result = await client.reply({
+          threadId: options.threadId,
+          body,
+          isHtml: options.html,
+        });
+        printSendResult(result);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gmail
+    .command('archive <message-id>')
+    .description('Archive a message')
+    .option('--profile <name>', 'Profile name')
+    .action(async (messageId: string, options) => {
+      try {
+        const { client } = await getGmailClient(options.profile);
+        await client.archive(messageId);
+        printArchived(messageId);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  gmail
+    .command('mark <message-id>')
+    .description('Mark message as read or unread')
+    .option('--profile <name>', 'Profile name')
+    .option('--read', 'Mark as read')
+    .option('--unread', 'Mark as unread')
+    .action(async (messageId: string, options) => {
+      try {
+        if (!options.read && !options.unread) {
+          throw new CliError('INVALID_PARAMS', 'Specify --read or --unread');
+        }
+        if (options.read && options.unread) {
+          throw new CliError('INVALID_PARAMS', 'Cannot specify both --read and --unread');
+        }
+
+        const { client } = await getGmailClient(options.profile);
+        await client.mark(messageId, options.read);
+        printMarked(messageId, options.read);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Profile management
+  const profile = gmail
+    .command('profile')
+    .description('Manage Gmail profiles');
+
+  profile
+    .command('add')
+    .description('Add a new Gmail profile')
+    .option('--profile <name>', 'Profile name', 'default')
+    .action(async (options) => {
+      try {
+        const profileName = options.profile;
+
+        console.error(`Starting OAuth flow for Gmail profile "${profileName}"...`);
+
+        const tokens = await performOAuthFlow('gmail');
+
+        await setProfile('gmail', profileName);
+        await setCredentials('gmail', profileName, tokens);
+
+        console.error(`\nSuccess! Profile "${profileName}" for Gmail is now configured.`);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  profile
+    .command('list')
+    .description('List Gmail profiles')
+    .action(async () => {
+      try {
+        const result = await listProfiles('gmail');
+        const { profiles, default: defaultProfile } = result[0];
+
+        if (profiles.length === 0) {
+          console.log('No profiles configured');
+        } else {
+          for (const name of profiles) {
+            const marker = name === defaultProfile ? ' (default)' : '';
+            console.log(`${name}${marker}`);
+          }
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  profile
+    .command('remove')
+    .description('Remove a Gmail profile')
+    .requiredOption('--profile <name>', 'Profile name')
+    .action(async (options) => {
+      try {
+        const profileName = options.profile;
+
+        const removed = await removeProfile('gmail', profileName);
+        await removeCredentials('gmail', profileName);
+
+        if (removed) {
+          console.error(`Removed profile "${profileName}"`);
+        } else {
+          console.error(`Profile "${profileName}" not found`);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/commands/telegram.ts

@@ -0,0 +1,247 @@
+import { Command } from 'commander';
+import { createInterface } from 'readline';
+import { setCredentials, removeCredentials, getCredentials } from '../auth/token-store';
+import { setProfile, removeProfile, listProfiles, getProfile } from '../config/config-manager';
+import { TelegramClient } from '../services/telegram/client';
+import { CliError, handleError } from '../utils/errors';
+import { readStdin } from '../utils/stdin';
+import type { TelegramCredentials, TelegramSendOptions } from '../types/telegram';
+
+function prompt(question: string): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+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',
+      'Run: agentio telegram profile add'
+    );
+  }
+
+  const credentials = await getCredentials<TelegramCredentials>('telegram', profile);
+
+  if (!credentials) {
+    throw new CliError(
+      'AUTH_FAILED',
+      `No credentials found for telegram profile "${profile}"`,
+      `Run: agentio telegram profile add --profile ${profile}`
+    );
+  }
+
+  return {
+    client: new TelegramClient(credentials.bot_token, credentials.channel_id),
+    profile,
+  };
+}
+
+export function registerTelegramCommands(program: Command): void {
+  const telegram = program
+    .command('telegram')
+    .description('Telegram operations');
+
+  telegram
+    .command('send')
+    .description('Send a message to the channel')
+    .option('--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)')
+    .action(async (message: string | undefined, options) => {
+      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 sendOptions: TelegramSendOptions = {};
+        if (options.parseMode) {
+          const mode = options.parseMode.toLowerCase();
+          if (mode === 'html') sendOptions.parse_mode = 'HTML';
+          else if (mode === 'markdown') sendOptions.parse_mode = 'MarkdownV2';
+          else throw new CliError('INVALID_PARAMS', 'parse-mode must be "html" or "markdown"');
+        }
+        if (options.silent) {
+          sendOptions.disable_notification = true;
+        }
+
+        const { client } = await getTelegramClient(options.profile);
+        const result = await client.sendMessage(text, sendOptions);
+
+        console.log('Message sent');
+        console.log(`ID: ${result.message_id}`);
+        console.log(`Chat: ${result.chat.title || result.chat.id}`);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  // Profile management
+  const profile = telegram
+    .command('profile')
+    .description('Manage Telegram profiles');
+
+  profile
+    .command('add')
+    .description('Add a new Telegram bot profile')
+    .option('--profile <name>', 'Profile name', 'default')
+    .action(async (options) => {
+      try {
+        const profileName = options.profile;
+
+        console.error('\n📱 Telegram Bot Setup\n');
+
+        // Step 1: Create bot
+        console.error('Step 1: Create your bot');
+        console.error('  Open Telegram and message @BotFather');
+        console.error('  → https://t.me/BotFather\n');
+        console.error('  Send these commands:');
+        console.error('    /newbot');
+        console.error('    → Enter a display name (e.g., "My Announcements Bot")');
+        console.error('    → Enter a username ending in "bot" (e.g., "my_announce_bot")\n');
+        console.error('  BotFather will give you a token like:');
+        console.error('    123456789:ABCdefGHIjklMNOpqrsTUVwxyz\n');
+
+        const botToken = await prompt('? Paste your bot token: ');
+
+        if (!botToken) {
+          throw new CliError('INVALID_PARAMS', 'Bot token is required');
+        }
+
+        // Validate token
+        const tempClient = new TelegramClient(botToken, '');
+        let botInfo;
+        try {
+          botInfo = await tempClient.getMe();
+        } catch (error) {
+          if (error instanceof CliError && error.code === 'AUTH_FAILED') {
+            throw new CliError('AUTH_FAILED', 'Invalid bot token. Please check and try again.');
+          }
+          throw error;
+        }
+
+        console.error(`\n✓ Bot verified: @${botInfo.username}\n`);
+
+        // Step 2: Add bot to channel
+        console.error('Step 2: Add bot to your channel');
+        console.error('  1. Open your Telegram channel');
+        console.error('  2. Go to Channel Settings → Administrators');
+        console.error(`  3. Add @${botInfo.username} as admin with "Post Messages" permission\n`);
+
+        console.error('  How to find your channel ID:');
+        console.error('  • Public channel: Use @username (e.g., @mychannel)');
+        console.error('  • Private channel: Forward any message from the channel to @userinfobot');
+        console.error('    The bot will reply with the channel ID (starts with -100)\n');
+
+        const channelId = await prompt('? Enter channel ID: ');
+
+        if (!channelId) {
+          throw new CliError('INVALID_PARAMS', 'Channel ID is required');
+        }
+
+        // Validate channel access
+        const client = new TelegramClient(botToken, channelId);
+        let chatInfo;
+        try {
+          chatInfo = await client.getChat();
+        } catch (error) {
+          if (error instanceof CliError) {
+            if (error.code === 'NOT_FOUND') {
+              throw new CliError('NOT_FOUND', `Channel "${channelId}" not found. Check the channel ID or username.`);
+            }
+            if (error.code === 'PERMISSION_DENIED') {
+              throw new CliError('PERMISSION_DENIED', `Bot cannot access "${channelId}". Make sure it's added as an admin.`);
+            }
+          }
+          throw error;
+        }
+
+        const channelName = chatInfo.title || chatInfo.username || channelId;
+        console.error(`\n✓ Channel verified: ${channelName}`);
+        console.error('✓ Bot can post to this channel\n');
+
+        // Step 3: Optional customization tips
+        console.error('Step 3: Customize your bot (optional)');
+        console.error('  You can set a profile photo and description in @BotFather:');
+        console.error('    /setuserpic - Set bot photo');
+        console.error('    /setdescription - Set bot description\n');
+
+        // Save credentials
+        const credentials: TelegramCredentials = {
+          bot_token: botToken,
+          channel_id: channelId,
+          bot_username: botInfo.username,
+        };
+
+        await setProfile('telegram', profileName);
+        await setCredentials('telegram', profileName, credentials);
+
+        console.error(`✅ Profile "${profileName}" configured!`);
+        console.error(`   Test with: agentio telegram send --profile ${profileName} "Hello world"`);
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  profile
+    .command('list')
+    .description('List Telegram profiles')
+    .action(async () => {
+      try {
+        const result = await listProfiles('telegram');
+        const { profiles, default: defaultProfile } = result[0];
+
+        if (profiles.length === 0) {
+          console.log('No profiles configured');
+        } else {
+          for (const name of profiles) {
+            const marker = name === defaultProfile ? ' (default)' : '';
+            console.log(`${name}${marker}`);
+          }
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+
+  profile
+    .command('remove')
+    .description('Remove a Telegram profile')
+    .requiredOption('--profile <name>', 'Profile name')
+    .action(async (options) => {
+      try {
+        const profileName = options.profile;
+
+        const removed = await removeProfile('telegram', profileName);
+        await removeCredentials('telegram', profileName);
+
+        if (removed) {
+          console.error(`Removed profile "${profileName}"`);
+        } else {
+          console.error(`Profile "${profileName}" not found`);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    });
+}

package/src/config/config-manager.ts

@@ -0,0 +1,127 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { mkdir, readFile, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import type { Config, ServiceName } from '../types/config';
+
+const CONFIG_DIR = join(homedir(), '.config', 'agentio');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+const DEFAULT_CONFIG: Config = {
+  profiles: {},
+  defaults: {},
+};
+
+export async function ensureConfigDir(): Promise<void> {
+  if (!existsSync(CONFIG_DIR)) {
+    await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+export async function loadConfig(): Promise<Config> {
+  await ensureConfigDir();
+
+  if (!existsSync(CONFIG_FILE)) {
+    await saveConfig(DEFAULT_CONFIG);
+    return DEFAULT_CONFIG;
+  }
+
+  try {
+    const content = await readFile(CONFIG_FILE, 'utf-8');
+    return JSON.parse(content) as Config;
+  } catch {
+    // Config file corrupted, back it up and return default
+    const backupPath = `${CONFIG_FILE}.backup`;
+    const content = await readFile(CONFIG_FILE, 'utf-8').catch(() => '');
+    if (content) {
+      await writeFile(backupPath, content).catch(() => {});
+    }
+    await saveConfig(DEFAULT_CONFIG);
+    return DEFAULT_CONFIG;
+  }
+}
+
+export async function saveConfig(config: Config): Promise<void> {
+  await ensureConfigDir();
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+export async function getProfile(
+  service: ServiceName,
+  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)) {
+    return null;
+  }
+
+  return name;
+}
+
+export async function setProfile(
+  service: ServiceName,
+  profileName: string
+): Promise<void> {
+  const config = await loadConfig();
+
+  if (!config.profiles[service]) {
+    config.profiles[service] = [];
+  }
+
+  if (!config.profiles[service]!.includes(profileName)) {
+    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);
+}
+
+export async function removeProfile(
+  service: ServiceName,
+  profileName: string
+): Promise<boolean> {
+  const config = await loadConfig();
+
+  const serviceProfiles = config.profiles[service];
+  if (!serviceProfiles || !serviceProfiles.includes(profileName)) {
+    return false;
+  }
+
+  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 listProfiles(service?: ServiceName): Promise<{
+  service: ServiceName;
+  profiles: string[];
+  default?: string;
+}[]> {
+  const config = await loadConfig();
+  const services: ServiceName[] = service ? [service] : ['gmail', 'gchat', 'jira', 'telegram'];
+
+  return services.map((svc) => ({
+    service: svc,
+    profiles: config.profiles[svc] || [],
+    default: config.defaults[svc],
+  }));
+}
+
+export { CONFIG_DIR, CONFIG_FILE };

package/src/config/credentials.ts

@@ -0,0 +1,7 @@
+// Embedded OAuth credentials for agentio
+// These are "public" credentials for a desktop/CLI app - this is standard practice
+
+export const GOOGLE_OAUTH_CONFIG = {
+  clientId: '125936797748-gju6s8niabdqtp3bnmoapsp5gou1vekb.apps.googleusercontent.com',
+  clientSecret: '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',
+};

package/src/index.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env bun
+import { Command } from 'commander';
+import { registerGmailCommands } from './commands/gmail';
+import { registerTelegramCommands } from './commands/telegram';
+
+const program = new Command();
+
+program
+  .name('agentio')
+  .description('CLI for LLM agents to interact with communication and tracking services')
+  .version('0.1.0');
+
+registerGmailCommands(program);
+registerTelegramCommands(program);
+
+program.parse();