@plosson/agentio 0.4.2 → 0.4.4

package/src/services/gsheets/client.ts

@@ -0,0 +1,362 @@
+import { google } from 'googleapis';
+import type { sheets_v4, drive_v3 } from 'googleapis';
+import { CliError, httpStatusToErrorCode, type ErrorCode } from '../../utils/errors';
+import type { ServiceClient, ValidationResult } from '../../types/service';
+import { GOOGLE_OAUTH_CONFIG } from '../../config/credentials';
+import type {
+  GSheetsCredentials,
+  GSheetsSpreadsheet,
+  GSheetsSheet,
+  GSheetsGetOptions,
+  GSheetsGetResult,
+  GSheetsUpdateOptions,
+  GSheetsUpdateResult,
+  GSheetsAppendOptions,
+  GSheetsAppendResult,
+  GSheetsClearResult,
+  GSheetsCreateResult,
+  GSheetsListOptions,
+  GSheetsListItem,
+} from '../../types/gsheets';
+
+export class GSheetsClient implements ServiceClient {
+  private credentials: GSheetsCredentials;
+  private sheets: sheets_v4.Sheets;
+  private drive: drive_v3.Drive;
+
+  constructor(credentials: GSheetsCredentials) {
+    this.credentials = credentials;
+    const auth = this.createOAuthClient();
+    this.sheets = google.sheets({ version: 'v4', auth });
+    this.drive = google.drive({ version: 'v3', auth });
+  }
+
+  async validate(): Promise<ValidationResult> {
+    try {
+      await this.drive.files.list({
+        pageSize: 1,
+        q: "mimeType='application/vnd.google-apps.spreadsheet'",
+      });
+      return { valid: true, info: this.credentials.email };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      if (message.includes('invalid_grant') || message.includes('Token has been expired or revoked')) {
+        return { valid: false, error: 'refresh token expired, re-authenticate' };
+      }
+      return { valid: false, error: message };
+    }
+  }
+
+  async list(options: GSheetsListOptions = {}): Promise<GSheetsListItem[]> {
+    const { limit = 10, query } = options;
+
+    try {
+      let q = "mimeType='application/vnd.google-apps.spreadsheet' and trashed=false";
+      if (query) {
+        q += ` and ${query}`;
+      }
+
+      const response = await this.drive.files.list({
+        pageSize: Math.min(limit, 100),
+        q,
+        fields: 'files(id,name,owners,createdTime,modifiedTime,webViewLink)',
+        orderBy: 'modifiedTime desc',
+      });
+
+      const files = response.data.files || [];
+      return files.map((file) => ({
+        id: file.id!,
+        title: file.name || 'Untitled',
+        owner: file.owners?.[0]?.displayName || file.owners?.[0]?.emailAddress || undefined,
+        createdTime: file.createdTime || undefined,
+        modifiedTime: file.modifiedTime || undefined,
+        webViewLink: file.webViewLink || `https://docs.google.com/spreadsheets/d/${file.id}`,
+      }));
+    } catch (err) {
+      this.throwApiError(err, 'list spreadsheets');
+    }
+  }
+
+  async get(spreadsheetIdOrUrl: string, range: string, options: GSheetsGetOptions = {}): Promise<GSheetsGetResult> {
+    const spreadsheetId = this.extractSpreadsheetId(spreadsheetIdOrUrl);
+    const cleanedRange = this.cleanRange(range);
+
+    try {
+      const call = this.sheets.spreadsheets.values.get({
+        spreadsheetId,
+        range: cleanedRange,
+        majorDimension: options.majorDimension,
+        valueRenderOption: options.valueRenderOption,
+      });
+
+      const response = await call;
+
+      return {
+        range: response.data.range || cleanedRange,
+        values: (response.data.values as unknown[][]) || [],
+      };
+    } catch (err) {
+      this.throwApiError(err, 'get values');
+    }
+  }
+
+  async update(
+    spreadsheetIdOrUrl: string,
+    range: string,
+    values: unknown[][],
+    options: GSheetsUpdateOptions = {}
+  ): Promise<GSheetsUpdateResult> {
+    const spreadsheetId = this.extractSpreadsheetId(spreadsheetIdOrUrl);
+    const cleanedRange = this.cleanRange(range);
+    const valueInputOption = options.valueInputOption || 'USER_ENTERED';
+
+    try {
+      const response = await this.sheets.spreadsheets.values.update({
+        spreadsheetId,
+        range: cleanedRange,
+        valueInputOption,
+        requestBody: {
+          values,
+        },
+      });
+
+      return {
+        updatedRange: response.data.updatedRange || cleanedRange,
+        updatedRows: response.data.updatedRows || 0,
+        updatedColumns: response.data.updatedColumns || 0,
+        updatedCells: response.data.updatedCells || 0,
+      };
+    } catch (err) {
+      this.throwApiError(err, 'update values');
+    }
+  }
+
+  async append(
+    spreadsheetIdOrUrl: string,
+    range: string,
+    values: unknown[][],
+    options: GSheetsAppendOptions = {}
+  ): Promise<GSheetsAppendResult> {
+    const spreadsheetId = this.extractSpreadsheetId(spreadsheetIdOrUrl);
+    const cleanedRange = this.cleanRange(range);
+    const valueInputOption = options.valueInputOption || 'USER_ENTERED';
+
+    try {
+      const response = await this.sheets.spreadsheets.values.append({
+        spreadsheetId,
+        range: cleanedRange,
+        valueInputOption,
+        insertDataOption: options.insertDataOption,
+        requestBody: {
+          values,
+        },
+      });
+
+      const updates = response.data.updates;
+      return {
+        updatedRange: updates?.updatedRange || cleanedRange,
+        updatedRows: updates?.updatedRows || 0,
+        updatedColumns: updates?.updatedColumns || 0,
+        updatedCells: updates?.updatedCells || 0,
+      };
+    } catch (err) {
+      this.throwApiError(err, 'append values');
+    }
+  }
+
+  async clear(spreadsheetIdOrUrl: string, range: string): Promise<GSheetsClearResult> {
+    const spreadsheetId = this.extractSpreadsheetId(spreadsheetIdOrUrl);
+    const cleanedRange = this.cleanRange(range);
+
+    try {
+      const response = await this.sheets.spreadsheets.values.clear({
+        spreadsheetId,
+        range: cleanedRange,
+      });
+
+      return {
+        clearedRange: response.data.clearedRange || cleanedRange,
+      };
+    } catch (err) {
+      this.throwApiError(err, 'clear values');
+    }
+  }
+
+  async metadata(spreadsheetIdOrUrl: string): Promise<GSheetsSpreadsheet> {
+    const spreadsheetId = this.extractSpreadsheetId(spreadsheetIdOrUrl);
+
+    try {
+      const response = await this.sheets.spreadsheets.get({
+        spreadsheetId,
+      });
+
+      const props = response.data.properties!;
+      const sheets: GSheetsSheet[] = (response.data.sheets || []).map((sheet) => ({
+        id: sheet.properties?.sheetId || 0,
+        title: sheet.properties?.title || 'Untitled',
+        rowCount: sheet.properties?.gridProperties?.rowCount || 0,
+        columnCount: sheet.properties?.gridProperties?.columnCount || 0,
+      }));
+
+      return {
+        id: response.data.spreadsheetId!,
+        title: props.title || 'Untitled',
+        locale: props.locale || undefined,
+        timeZone: props.timeZone || undefined,
+        url: response.data.spreadsheetUrl || `https://docs.google.com/spreadsheets/d/${spreadsheetId}`,
+        sheets,
+      };
+    } catch (err) {
+      this.throwApiError(err, 'get metadata');
+    }
+  }
+
+  async create(title: string, sheetNames?: string[]): Promise<GSheetsCreateResult> {
+    try {
+      const sheets: sheets_v4.Schema$Sheet[] | undefined = sheetNames?.map((name) => ({
+        properties: {
+          title: name.trim(),
+        },
+      }));
+
+      const response = await this.sheets.spreadsheets.create({
+        requestBody: {
+          properties: {
+            title,
+          },
+          sheets,
+        },
+      });
+
+      return {
+        id: response.data.spreadsheetId!,
+        title: response.data.properties?.title || title,
+        url: response.data.spreadsheetUrl || `https://docs.google.com/spreadsheets/d/${response.data.spreadsheetId}`,
+      };
+    } catch (err) {
+      this.throwApiError(err, 'create spreadsheet');
+    }
+  }
+
+  async copy(spreadsheetIdOrUrl: string, newTitle: string, parentFolderId?: string): Promise<GSheetsCreateResult> {
+    const spreadsheetId = this.extractSpreadsheetId(spreadsheetIdOrUrl);
+
+    try {
+      const response = await this.drive.files.copy({
+        fileId: spreadsheetId,
+        requestBody: {
+          name: newTitle,
+          parents: parentFolderId ? [parentFolderId] : undefined,
+        },
+        fields: 'id,name,webViewLink',
+      });
+
+      return {
+        id: response.data.id!,
+        title: response.data.name || newTitle,
+        url: response.data.webViewLink || `https://docs.google.com/spreadsheets/d/${response.data.id}`,
+      };
+    } catch (err) {
+      this.throwApiError(err, 'copy spreadsheet');
+    }
+  }
+
+  async export(
+    spreadsheetIdOrUrl: string,
+    format: 'xlsx' | 'pdf' | 'csv' | 'ods' | 'tsv'
+  ): Promise<{ data: Buffer; mimeType: string; extension: string }> {
+    const spreadsheetId = this.extractSpreadsheetId(spreadsheetIdOrUrl);
+
+    const formatMap: Record<string, { mimeType: string; extension: string }> = {
+      xlsx: {
+        mimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        extension: '.xlsx',
+      },
+      pdf: { mimeType: 'application/pdf', extension: '.pdf' },
+      csv: { mimeType: 'text/csv', extension: '.csv' },
+      ods: { mimeType: 'application/vnd.oasis.opendocument.spreadsheet', extension: '.ods' },
+      tsv: { mimeType: 'text/tab-separated-values', extension: '.tsv' },
+    };
+
+    const formatInfo = formatMap[format];
+    if (!formatInfo) {
+      throw new CliError('INVALID_PARAMS', `Unknown export format: ${format}`, 'Use xlsx, pdf, csv, ods, or tsv');
+    }
+
+    try {
+      const response = await this.drive.files.export(
+        { fileId: spreadsheetId, mimeType: formatInfo.mimeType },
+        { responseType: 'arraybuffer' }
+      );
+
+      return {
+        data: Buffer.from(response.data as ArrayBuffer),
+        mimeType: formatInfo.mimeType,
+        extension: formatInfo.extension,
+      };
+    } catch (err) {
+      this.throwApiError(err, 'export spreadsheet');
+    }
+  }
+
+  private extractSpreadsheetId(idOrUrl: string): string {
+    // Handle URLs like https://docs.google.com/spreadsheets/d/SPREADSHEET_ID/edit
+    const urlMatch = idOrUrl.match(/\/spreadsheets\/d\/([a-zA-Z0-9_-]+)/);
+    if (urlMatch) return urlMatch[1];
+
+    // Handle other URL formats
+    const idMatch = idOrUrl.match(/id=([a-zA-Z0-9_-]+)/);
+    if (idMatch) return idMatch[1];
+
+    // Assume it's already an ID
+    return idOrUrl;
+  }
+
+  private cleanRange(range: string): string {
+    // Some shells escape ! to \! (bash history expansion), which breaks API calls
+    return range.replace(/\\!/g, '!');
+  }
+
+  private createOAuthClient() {
+    const oauth2Client = new google.auth.OAuth2(
+      GOOGLE_OAUTH_CONFIG.clientId,
+      GOOGLE_OAUTH_CONFIG.clientSecret
+    );
+
+    oauth2Client.setCredentials({
+      access_token: this.credentials.accessToken,
+      refresh_token: this.credentials.refreshToken,
+      expiry_date: this.credentials.expiryDate,
+    });
+
+    return oauth2Client;
+  }
+
+  private throwApiError(err: unknown, operation: string): never {
+    const code = this.getErrorCode(err);
+    const message = this.getErrorMessage(err);
+    throw new CliError(code, `Failed to ${operation}: ${message}`);
+  }
+
+  private getErrorCode(err: unknown): ErrorCode {
+    if (err && typeof err === 'object') {
+      const error = err as Record<string, unknown>;
+      const code = error.code || error.status;
+      if (typeof code === 'number') return httpStatusToErrorCode(code);
+    }
+    return 'API_ERROR';
+  }
+
+  private getErrorMessage(err: unknown): string {
+    if (err && typeof err === 'object') {
+      const error = err as Record<string, unknown>;
+      const code = error.code || error.status;
+      if (code === 401) return 'OAuth token expired or invalid';
+      if (code === 403) return 'Insufficient permissions to access this spreadsheet';
+      if (code === 404) return 'Spreadsheet not found';
+      if (code === 429) return 'Rate limit exceeded, please try again later';
+      if (error.message && typeof error.message === 'string') return error.message;
+    }
+    return err instanceof Error ? err.message : String(err);
+  }
+}

package/src/services/gtasks/client.ts

@@ -0,0 +1,301 @@
+import { google, tasks_v1 } from 'googleapis';
+import type { OAuth2Client } from 'google-auth-library';
+import type {
+  GTaskList,
+  GTask,
+  GTasksListOptions,
+  GTasksCreateOptions,
+  GTasksUpdateOptions,
+} from '../../types/gtasks';
+import type { ServiceClient, ValidationResult } from '../../types/service';
+import { CliError } from '../../utils/errors';
+
+export class GTasksClient implements ServiceClient {
+  private tasks: tasks_v1.Tasks;
+  private userEmail: string | null = null;
+
+  constructor(auth: OAuth2Client) {
+    this.tasks = google.tasks({ version: 'v1', auth });
+  }
+
+  async validate(): Promise<ValidationResult> {
+    try {
+      // Try to list task lists to verify credentials work
+      await this.tasks.tasklists.list({ maxResults: 1 });
+      return { valid: true, info: 'tasks access ok' };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      if (message.includes('invalid_grant') || message.includes('Token has been expired or revoked')) {
+        return { valid: false, error: 'refresh token expired, re-authenticate' };
+      }
+      return { valid: false, error: message };
+    }
+  }
+
+  async listTaskLists(maxResults: number = 100, pageToken?: string): Promise<{ taskLists: GTaskList[]; nextPageToken?: string }> {
+    try {
+      const response = await this.tasks.tasklists.list({
+        maxResults: Math.min(maxResults, 100),
+        pageToken,
+      });
+
+      const taskLists: GTaskList[] = (response.data.items || []).map((tl) => ({
+        id: tl.id!,
+        title: tl.title || '',
+        updated: tl.updated || undefined,
+        selfLink: tl.selfLink || undefined,
+      }));
+
+      return {
+        taskLists,
+        nextPageToken: response.data.nextPageToken || undefined,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Tasks API error: ${message}`);
+    }
+  }
+
+  async createTaskList(title: string): Promise<GTaskList> {
+    try {
+      const response = await this.tasks.tasklists.insert({
+        requestBody: { title },
+      });
+
+      return {
+        id: response.data.id!,
+        title: response.data.title || '',
+        updated: response.data.updated || undefined,
+        selfLink: response.data.selfLink || undefined,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to create task list: ${message}`);
+    }
+  }
+
+  async deleteTaskList(tasklistId: string): Promise<void> {
+    try {
+      await this.tasks.tasklists.delete({ tasklist: tasklistId });
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        throw new CliError('NOT_FOUND', `Task list not found: ${tasklistId}`);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to delete task list: ${message}`);
+    }
+  }
+
+  async listTasks(options: GTasksListOptions): Promise<{ tasks: GTask[]; nextPageToken?: string }> {
+    const {
+      tasklistId,
+      maxResults = 20,
+      pageToken,
+      showCompleted = true,
+      showDeleted = false,
+      showHidden = false,
+      dueMin,
+      dueMax,
+      completedMin,
+      completedMax,
+      updatedMin,
+    } = options;
+
+    try {
+      const params: tasks_v1.Params$Resource$Tasks$List = {
+        tasklist: tasklistId,
+        maxResults: Math.min(maxResults, 100),
+        showCompleted,
+        showDeleted,
+        showHidden,
+      };
+
+      if (pageToken) params.pageToken = pageToken;
+      if (dueMin) params.dueMin = dueMin;
+      if (dueMax) params.dueMax = dueMax;
+      if (completedMin) params.completedMin = completedMin;
+      if (completedMax) params.completedMax = completedMax;
+      if (updatedMin) params.updatedMin = updatedMin;
+
+      const response = await this.tasks.tasks.list(params);
+
+      const tasks: GTask[] = (response.data.items || []).map((t) => this.parseTask(t));
+
+      return {
+        tasks,
+        nextPageToken: response.data.nextPageToken || undefined,
+      };
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        throw new CliError('NOT_FOUND', `Task list not found: ${tasklistId}`);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Tasks API error: ${message}`);
+    }
+  }
+
+  async getTask(tasklistId: string, taskId: string): Promise<GTask> {
+    try {
+      const response = await this.tasks.tasks.get({
+        tasklist: tasklistId,
+        task: taskId,
+      });
+
+      return this.parseTask(response.data);
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        throw new CliError('NOT_FOUND', `Task not found: ${taskId}`);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Tasks API error: ${message}`);
+    }
+  }
+
+  async createTask(options: GTasksCreateOptions): Promise<GTask> {
+    const { tasklistId, title, notes, due, parent, previous } = options;
+
+    try {
+      const task: tasks_v1.Schema$Task = {
+        title,
+        notes,
+        due: due ? this.normalizeDue(due) : undefined,
+      };
+
+      const params: tasks_v1.Params$Resource$Tasks$Insert = {
+        tasklist: tasklistId,
+        requestBody: task,
+      };
+
+      if (parent) params.parent = parent;
+      if (previous) params.previous = previous;
+
+      const response = await this.tasks.tasks.insert(params);
+
+      return this.parseTask(response.data);
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        throw new CliError('NOT_FOUND', `Task list not found: ${tasklistId}`);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to create task: ${message}`);
+    }
+  }
+
+  async updateTask(options: GTasksUpdateOptions): Promise<GTask> {
+    const { tasklistId, taskId, title, notes, due, status } = options;
+
+    try {
+      const patch: tasks_v1.Schema$Task = {};
+
+      if (title !== undefined) patch.title = title;
+      if (notes !== undefined) patch.notes = notes;
+      if (due !== undefined) patch.due = due ? this.normalizeDue(due) : null;
+      if (status !== undefined) patch.status = status;
+
+      const response = await this.tasks.tasks.patch({
+        tasklist: tasklistId,
+        task: taskId,
+        requestBody: patch,
+      });
+
+      return this.parseTask(response.data);
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        throw new CliError('NOT_FOUND', `Task not found: ${taskId}`);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to update task: ${message}`);
+    }
+  }
+
+  async completeTask(tasklistId: string, taskId: string): Promise<GTask> {
+    return this.updateTask({ tasklistId, taskId, status: 'completed' });
+  }
+
+  async uncompleteTask(tasklistId: string, taskId: string): Promise<GTask> {
+    return this.updateTask({ tasklistId, taskId, status: 'needsAction' });
+  }
+
+  async deleteTask(tasklistId: string, taskId: string): Promise<void> {
+    try {
+      await this.tasks.tasks.delete({
+        tasklist: tasklistId,
+        task: taskId,
+      });
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        throw new CliError('NOT_FOUND', `Task not found: ${taskId}`);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to delete task: ${message}`);
+    }
+  }
+
+  async clearCompleted(tasklistId: string): Promise<void> {
+    try {
+      await this.tasks.tasks.clear({ tasklist: tasklistId });
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        throw new CliError('NOT_FOUND', `Task list not found: ${tasklistId}`);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to clear completed tasks: ${message}`);
+    }
+  }
+
+  async moveTask(tasklistId: string, taskId: string, parent?: string, previous?: string): Promise<GTask> {
+    try {
+      const params: tasks_v1.Params$Resource$Tasks$Move = {
+        tasklist: tasklistId,
+        task: taskId,
+      };
+
+      if (parent) params.parent = parent;
+      if (previous) params.previous = previous;
+
+      const response = await this.tasks.tasks.move(params);
+
+      return this.parseTask(response.data);
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        throw new CliError('NOT_FOUND', `Task not found: ${taskId}`);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new CliError('API_ERROR', `Failed to move task: ${message}`);
+    }
+  }
+
+  private normalizeDue(due: string): string {
+    // If it's already RFC3339, return as-is
+    if (due.includes('T')) {
+      return due;
+    }
+    // If it's just a date (YYYY-MM-DD), convert to RFC3339 with midnight UTC
+    return `${due}T00:00:00.000Z`;
+  }
+
+  private parseTask(task: tasks_v1.Schema$Task): GTask {
+    return {
+      id: task.id!,
+      title: task.title || '',
+      status: (task.status as 'needsAction' | 'completed') || 'needsAction',
+      notes: task.notes || undefined,
+      due: task.due || undefined,
+      completed: task.completed || undefined,
+      parent: task.parent || undefined,
+      position: task.position || undefined,
+      updated: task.updated || undefined,
+      selfLink: task.selfLink || undefined,
+      webViewLink: task.webViewLink || undefined,
+      hidden: task.hidden || undefined,
+      deleted: task.deleted || undefined,
+    };
+  }
+
+  private isNotFoundError(error: unknown): boolean {
+    if (error && typeof error === 'object' && 'code' in error) {
+      return (error as { code: unknown }).code === 404;
+    }
+    return false;
+  }
+}