@plosson/agentio 0.3.1 → 0.4.0

package/src/types/gdrive.ts

@@ -0,0 +1,81 @@
+export type GDriveAccessLevel = 'readonly' | 'full';
+
+export interface GDriveCredentials {
+  accessToken: string;
+  refreshToken?: string;
+  expiryDate?: number;
+  tokenType: string;
+  scope?: string;
+  email: string;
+  accessLevel: GDriveAccessLevel;
+}
+
+export interface GDriveFile {
+  id: string;
+  name: string;
+  mimeType: string;
+  size?: number;
+  createdTime?: string;
+  modifiedTime?: string;
+  owners?: string[];
+  parents?: string[];
+  webViewLink?: string;
+  webContentLink?: string;
+  starred: boolean;
+  trashed: boolean;
+  shared: boolean;
+  description?: string;
+}
+
+export interface GDriveListOptions {
+  limit?: number;
+  folderId?: string;
+  query?: string;
+  orderBy?: string;
+  includeTrash?: boolean;
+}
+
+export interface GDriveSearchOptions {
+  query: string;
+  mimeType?: string;
+  limit?: number;
+  folderId?: string;
+}
+
+export interface GDriveFolderListOptions {
+  limit?: number;
+  parentId?: string;
+  query?: string;
+}
+
+export interface GDriveDownloadOptions {
+  fileIdOrUrl: string;
+  outputPath: string;
+  exportFormat?: GDriveExportFormat;
+}
+
+export interface GDriveDownloadResult {
+  filename: string;
+  path: string;
+  size: number;
+  mimeType: string;
+}
+
+// Export formats for Google Workspace files
+export type GDriveExportFormat = 'pdf' | 'docx' | 'xlsx' | 'csv' | 'pptx' | 'txt' | 'html' | 'odt' | 'ods' | 'odp' | 'rtf' | 'tsv' | 'png' | 'jpeg' | 'svg';
+
+export interface GDriveUploadOptions {
+  filePath: string;
+  name?: string;
+  folderId?: string;
+  mimeType?: string;
+  convert?: boolean;
+}
+
+export interface GDriveUploadResult {
+  id: string;
+  name: string;
+  mimeType: string;
+  size: number;
+  webViewLink?: string;
+}

package/src/types/telegram.ts

@@ -1,8 +1,8 @@
 export interface TelegramCredentials {
-  bot_token: string;
-  channel_id: string;
-  bot_username?: string;
-  channel_name?: string;
+  botToken: string;
+  channelId: string;
+  botUsername?: string;
+  channelName?: string;
 }
 
 export interface TelegramBotInfo {

package/src/utils/client-factory.ts

@@ -0,0 +1,56 @@
+import { getCredentials } from '../auth/token-store';
+import { resolveProfile } from '../config/config-manager';
+import { CliError } from './errors';
+import type { ServiceName } from '../types/config';
+
+export interface ClientFactoryConfig<TCredentials, TClient> {
+  service: ServiceName;
+  createClient: (credentials: TCredentials) => TClient;
+}
+
+/**
+ * Creates a type-safe client getter function for a service.
+ * Profile is optional - if only one profile exists, it will be used automatically.
+ *
+ * Usage:
+ * ```typescript
+ * const getSlackClient = createClientGetter<SlackCredentials, SlackClient>({
+ *   service: 'slack',
+ *   createClient: (credentials) => new SlackClient(credentials),
+ * });
+ * ```
+ */
+export function createClientGetter<TCredentials, TClient>(
+  config: ClientFactoryConfig<TCredentials, TClient>
+): (profileName?: string) => Promise<{ client: TClient; profile: string }> {
+  const { service, createClient } = config;
+
+  return async (profileName?: string): Promise<{ client: TClient; profile: string }> => {
+    const { profile, error } = await resolveProfile(service, profileName);
+
+    if (!profile) {
+      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 credentials = await getCredentials<TCredentials>(service, profile);
+
+    if (!credentials) {
+      throw new CliError(
+        'AUTH_FAILED',
+        `No credentials found for ${service} profile "${profile}"`,
+        `Run: agentio ${service} profile add --profile ${profile}`
+      );
+    }
+
+    return {
+      client: createClient(credentials),
+      profile,
+    };
+  };
+}

package/src/utils/errors.ts

@@ -10,6 +10,18 @@ export type ErrorCode =
   | 'NOT_FOUND'
   | 'CONFIG_ERROR';
 
+/**
+ * Map HTTP status codes to standard error codes.
+ * Use this in API clients to standardize error handling.
+ */
+export function httpStatusToErrorCode(status: number): ErrorCode {
+  if (status === 401) return 'AUTH_FAILED';
+  if (status === 403) return 'PERMISSION_DENIED';
+  if (status === 404) return 'NOT_FOUND';
+  if (status === 429) return 'RATE_LIMITED';
+  return 'API_ERROR';
+}
+
 export class CliError extends Error {
   constructor(
     public code: ErrorCode,

package/src/utils/obscure.ts

@@ -1,5 +1,18 @@
 import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';
 
+/**
+ * Simple obfuscation utilities for embedding secrets in source code.
+ *
+ * NOT for real security - just prevents secret scanners from flagging embedded
+ * OAuth client secrets. Uses the same pattern as rclone.
+ *
+ * obscure() is exported for generating new obscured values (run in a scratch file):
+ *   import { obscure } from './src/utils/obscure';
+ *   console.log(obscure('your-secret-here'));
+ *
+ * reveal() is used at runtime to decode the obscured values.
+ */
+
 // Hardcoded key for obfuscation (not real security, just to avoid secret scanners)
 // This is the same pattern rclone uses
 const OBSCURE_KEY = Buffer.from('9c935b2aa628f0e9d48d5f3e8a4b7c1d2e3f4a5b6c7d8e9f0a1b2c3d4e5f6a7b', 'hex');

package/src/utils/output.ts

@@ -1,5 +1,7 @@
 import type { GmailMessage, GmailAttachmentInfo } from '../types/gmail';
 import type { GChatMessage, GChatSpace } from '../types/gchat';
+import type { GDocsDocument, GDocsCreateResult } from '../types/gdocs';
+import type { GDriveFile, GDriveDownloadResult, GDriveUploadResult } from '../types/gdrive';
 import type { JiraProject, JiraIssue, JiraTransition, JiraCommentResult, JiraTransitionResult } from '../types/jira';
 import type { SlackSendResult } from '../types/slack';
 import type { RssFeed, RssArticle } from '../types/rss';
@@ -373,3 +375,110 @@ export function printDiscourseTopic(topic: DiscourseTopicDetail): void {
     console.log(content);
   }
 }
+
+// Google Docs specific formatters
+export function printGDocsList(docs: GDocsDocument[]): void {
+  if (docs.length === 0) {
+    console.log('No documents found');
+    return;
+  }
+
+  console.log(`Documents (${docs.length})\n`);
+
+  for (let i = 0; i < docs.length; i++) {
+    const doc = docs[i];
+    console.log(`[${i + 1}] ${doc.title}`);
+    console.log(`    ID: ${doc.id}`);
+    if (doc.owner) console.log(`    Owner: ${doc.owner}`);
+    if (doc.modifiedTime) console.log(`    Modified: ${doc.modifiedTime}`);
+    console.log(`    Link: ${doc.webViewLink}`);
+    console.log('');
+  }
+}
+
+export function printGDocCreated(result: GDocsCreateResult): void {
+  console.log('Document created');
+  console.log(`ID: ${result.id}`);
+  console.log(`Title: ${result.title}`);
+  console.log(`Link: ${result.webViewLink}`);
+}
+
+// Google Drive specific formatters
+function getShortMimeType(mimeType: string): string {
+  const shortTypes: Record<string, string> = {
+    'application/vnd.google-apps.folder': 'folder',
+    'application/vnd.google-apps.document': 'gdoc',
+    'application/vnd.google-apps.spreadsheet': 'gsheet',
+    'application/vnd.google-apps.presentation': 'gslide',
+    'application/pdf': 'pdf',
+    'image/png': 'png',
+    'image/jpeg': 'jpg',
+    'text/plain': 'txt',
+    'application/zip': 'zip',
+  };
+  if (shortTypes[mimeType]) return shortTypes[mimeType];
+  if (mimeType.startsWith('image/')) return 'image';
+  if (mimeType.startsWith('video/')) return 'video';
+  if (mimeType.startsWith('audio/')) return 'audio';
+  if (mimeType.startsWith('text/')) return 'text';
+  return 'file';
+}
+
+export function printGDriveFileList(files: GDriveFile[], title: string = 'Files'): void {
+  if (files.length === 0) {
+    console.log('No files found');
+    return;
+  }
+
+  console.log(`${title} (${files.length})\n`);
+
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const isFolder = file.mimeType === 'application/vnd.google-apps.folder';
+    const typeIndicator = isFolder ? '[folder]' : `[${getShortMimeType(file.mimeType)}]`;
+    const flags: string[] = [];
+    if (file.starred) flags.push('*');
+    if (file.shared) flags.push('shared');
+    const flagStr = flags.length > 0 ? ` (${flags.join(', ')})` : '';
+
+    console.log(`[${i + 1}] ${file.name} ${typeIndicator}${flagStr}`);
+    console.log(`    ID: ${file.id}`);
+    if (file.size) console.log(`    Size: ${formatBytes(file.size)}`);
+    if (file.owners?.length) console.log(`    Owner: ${file.owners[0]}`);
+    if (file.modifiedTime) console.log(`    Modified: ${file.modifiedTime}`);
+    if (file.webViewLink) console.log(`    Link: ${file.webViewLink}`);
+    console.log('');
+  }
+}
+
+export function printGDriveFile(file: GDriveFile): void {
+  console.log(`ID: ${file.id}`);
+  console.log(`Name: ${file.name}`);
+  console.log(`Type: ${file.mimeType}`);
+  if (file.size) console.log(`Size: ${formatBytes(file.size)}`);
+  if (file.description) console.log(`Description: ${file.description}`);
+  if (file.owners?.length) console.log(`Owners: ${file.owners.join(', ')}`);
+  if (file.parents?.length) console.log(`Parents: ${file.parents.join(', ')}`);
+  console.log(`Starred: ${file.starred ? 'yes' : 'no'}`);
+  console.log(`Shared: ${file.shared ? 'yes' : 'no'}`);
+  console.log(`Trashed: ${file.trashed ? 'yes' : 'no'}`);
+  if (file.createdTime) console.log(`Created: ${file.createdTime}`);
+  if (file.modifiedTime) console.log(`Modified: ${file.modifiedTime}`);
+  if (file.webViewLink) console.log(`View: ${file.webViewLink}`);
+  if (file.webContentLink) console.log(`Download: ${file.webContentLink}`);
+}
+
+export function printGDriveDownloaded(result: GDriveDownloadResult): void {
+  console.log(`Downloaded: ${result.filename}`);
+  console.log(`  Path: ${result.path}`);
+  console.log(`  Size: ${formatBytes(result.size)}`);
+  console.log(`  Type: ${result.mimeType}`);
+}
+
+export function printGDriveUploaded(result: GDriveUploadResult): void {
+  console.log(`Uploaded: ${result.name}`);
+  console.log(`  ID: ${result.id}`);
+  console.log(`  Size: ${formatBytes(result.size)}`);
+  console.log(`  Type: ${result.mimeType}`);
+  if (result.webViewLink) console.log(`  Link: ${result.webViewLink}`);
+}