@divyacon/piece-google-drive 0.0.0-stage → 0.1.0

package/src/lib/action/drive-update-reply.ts

@@ -0,0 +1,73 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveUpdateReplyOutputSchema } from '../output-schemas';
+
+export const driveUpdateReply = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_update_reply',
+  displayName: 'Update Reply',
+  description: 'Edit the text of an existing reply on a Drive comment.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Edits the text of an existing reply by ID (resolve via drive_list_replies). Use to correct or revise a reply you control; to add a new reply instead use drive_create_reply. Safe to retry — re-applying the same content is a no-op.',
+    idempotent: true,
+  },
+  outputSchema: driveUpdateReplyOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File ID',
+      description:
+        'The ID of the file the comment belongs to. Resolve it via drive_search_files or drive_get_file.',
+      required: true,
+    }),
+    comment_id: Property.ShortText({
+      displayName: 'Comment ID',
+      description: 'The ID of the parent comment. Resolve it via drive_list_comments.',
+      required: true,
+    }),
+    reply_id: Property.ShortText({
+      displayName: 'Reply ID',
+      description: 'The ID of the reply to update. Resolve it via drive_list_replies.',
+      required: true,
+    }),
+    content: Property.LongText({
+      displayName: 'Content',
+      description: 'The new plain-text content for the reply.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { file_id, comment_id, reply_id, content } = context.propsValue;
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    try {
+      // The Drive replies endpoints require a fields parameter or the API returns 400.
+      const response = await drive.replies.update({
+        fileId: file_id,
+        commentId: comment_id,
+        replyId: reply_id,
+        fields: '*',
+        requestBody: { content },
+      });
+
+      return response.data;
+    } catch (error: any) {
+      if (error.code === 404) {
+        throw new Error(
+          `File, comment, or reply not found (file ID: ${file_id}, comment ID: ${comment_id}, reply ID: ${reply_id}). Resolve the reply ID via drive_list_replies.`
+        );
+      }
+      if (error.code === 403) {
+        throw new Error(
+          `Permission denied updating reply ${reply_id} on file ${file_id}. You can only edit your own replies.`
+        );
+      }
+      throw error;
+    }
+  },
+});

package/src/lib/action/drive-update-shared-drive.ts

@@ -0,0 +1,63 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveUpdateSharedDriveOutputSchema } from '../output-schemas';
+
+export const driveUpdateSharedDrive = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_update_shared_drive',
+  displayName: 'Update Shared Drive',
+  description: 'Rename or update a shared drive by ID.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Renames or updates a shared drive\'s settings by ID (resolve via drive_list_shared_drives). Use to rename a shared drive; to remove it entirely use drive_delete_shared_drive. Safe to retry — re-applying the same values is a no-op.',
+    idempotent: true,
+  },
+  outputSchema: driveUpdateSharedDriveOutputSchema,
+  props: {
+    drive_id: Property.ShortText({
+      displayName: 'Shared Drive ID',
+      description: 'The ID of the shared drive to update. Resolve it via drive_list_shared_drives.',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'Name',
+      description: 'The new name for the shared drive. Leave empty to keep the current name.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const { drive_id, name } = context.propsValue;
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    const requestBody: { name?: string } = {};
+    if (name) {
+      requestBody.name = name;
+    }
+
+    try {
+      const response = await drive.drives.update({
+        driveId: drive_id,
+        requestBody,
+      });
+
+      return response.data;
+    } catch (error: any) {
+      if (error.code === 404) {
+        throw new Error(
+          `Shared drive not found (ID: ${drive_id}). Resolve a valid ID via drive_list_shared_drives.`
+        );
+      }
+      if (error.code === 403) {
+        throw new Error(
+          `Permission denied updating shared drive ${drive_id}. You must be an organizer of this drive.`
+        );
+      }
+      throw error;
+    }
+  },
+});

package/src/lib/action/drive-upload-file.ts

@@ -0,0 +1,80 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpMethod,
+  AuthenticationType,
+} from '@agnocon/pieces-common';
+import FormData from 'form-data';
+import { googleDriveAuth, getAccessToken } from '../auth';
+import mime from 'mime-types';
+import { driveUploadFileOutputSchema } from '../output-schemas';
+
+export const driveUploadFile = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_upload_file',
+  displayName: 'Upload File',
+  description: 'Upload a file in your Google Drive',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Uploads a binary file (from a URL or base64 input) into Drive; MIME type is inferred from the extension. Use to store an existing file or attachment; for plain generated text use `drive_create_file_from_text`, and to fetch a remote URL server-side use `drive_upload_from_url`. Each call creates a new file.',
+    idempotent: false,
+  },
+  outputSchema: driveUploadFileOutputSchema,
+  props: {
+    file_name: Property.ShortText({
+      displayName: 'File name',
+      description: 'The name of the file',
+      required: true,
+    }),
+    file: Property.File({
+      displayName: 'File',
+      description: 'The file URL or base64 to upload',
+      required: true,
+    }),
+    parent_folder_id: Property.ShortText({
+      displayName: 'Parent Folder ID',
+      description:
+        'The ID of the folder to upload the file into. Leave empty to upload to the root of My Drive. Resolve a folder ID with `drive_search_files`.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const fileData = context.propsValue.file;
+    const mimeType = mime.lookup(fileData.extension ? fileData.extension : '');
+
+    const meta = {
+      mimeType: mimeType,
+      name: context.propsValue.file_name,
+      ...(context.propsValue.parent_folder_id
+        ? { parents: [context.propsValue.parent_folder_id] }
+        : {}),
+    };
+
+    const metaBuffer = Buffer.from(JSON.stringify(meta), 'utf-8');
+    const fileBuffer = Buffer.from(fileData.base64, 'base64');
+
+    const form = new FormData();
+    form.append('Metadata', metaBuffer, { contentType: 'application/json' });
+    form.append('Media', fileBuffer);
+
+    const result = await httpClient.sendRequest({
+      method: HttpMethod.POST,
+      url: `https://www.googleapis.com/upload/drive/v3/files`,
+      queryParams: {
+        uploadType: 'multipart',
+        supportsAllDrives: 'true',
+      },
+      body: form,
+      headers: {
+        ...form.getHeaders(),
+      },
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: await getAccessToken(context.auth),
+      },
+    });
+
+    return result.body;
+  },
+});

package/src/lib/action/drive-upload-from-url.ts

@@ -0,0 +1,107 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpMethod,
+  AuthenticationType,
+} from '@agnocon/pieces-common';
+import FormData from 'form-data';
+import { googleDriveAuth, getAccessToken } from '../auth';
+import mime from 'mime-types';
+import { driveUploadFromUrlOutputSchema } from '../output-schemas';
+
+export const driveUploadFromUrl = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_upload_from_url',
+  displayName: 'Upload File from URL',
+  description: 'Fetch a file from a public URL and upload it into Google Drive.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Fetches a file from a public URL and uploads it into Drive in one step (server-side fetch, no base64 round-trip). Use when the agent has a downloadable link rather than file bytes; for bytes already in hand use `drive_upload_file`, and for plain generated text use `drive_create_file_from_text`. Each call creates a new file.',
+    idempotent: false,
+  },
+  outputSchema: driveUploadFromUrlOutputSchema,
+  props: {
+    source_url: Property.ShortText({
+      displayName: 'Source URL',
+      description:
+        'The publicly accessible URL to fetch the file from. Only public URLs are supported (no authentication headers are sent).',
+      required: true,
+    }),
+    file_name: Property.ShortText({
+      displayName: 'File name',
+      description: 'The name to give the uploaded file in Drive.',
+      required: true,
+    }),
+    mime_type: Property.ShortText({
+      displayName: 'MIME Type',
+      description:
+        'Optional MIME type for the uploaded file (e.g. application/pdf). Provide this when the URL has no file extension; otherwise the type is inferred from the URL.',
+      required: false,
+    }),
+    parent_folder_id: Property.ShortText({
+      displayName: 'Parent Folder ID',
+      description:
+        'The ID of the folder to upload the file into. Leave empty to upload to the root of My Drive. Resolve a folder ID with `drive_search_files`.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const { source_url, file_name, mime_type, parent_folder_id } =
+      context.propsValue;
+
+    // SSRF: only public URLs supported — no auth headers are forwarded and the
+    // caller is responsible for supplying a publicly reachable link.
+    let download;
+    try {
+      download = await httpClient.sendRequest<ArrayBuffer>({
+        method: HttpMethod.GET,
+        url: source_url,
+        responseType: 'arraybuffer',
+      });
+    } catch (error: any) {
+      throw new Error(
+        `Failed to fetch the file from the source URL (${source_url}). Ensure it is a publicly accessible link. Underlying error: ${
+          error?.message ?? error
+        }`
+      );
+    }
+
+    // Honor an explicit mime_type when the URL lacks an extension; otherwise
+    // infer it from the URL so Drive does not default everything to octet-stream.
+    const resolvedMimeType =
+      mime_type || mime.lookup(source_url) || 'application/octet-stream';
+
+    const meta = {
+      mimeType: resolvedMimeType,
+      name: file_name,
+      ...(parent_folder_id ? { parents: [parent_folder_id] } : {}),
+    };
+
+    const metaBuffer = Buffer.from(JSON.stringify(meta), 'utf-8');
+    const fileBuffer = Buffer.from(download.body);
+
+    const form = new FormData();
+    form.append('Metadata', metaBuffer, { contentType: 'application/json' });
+    form.append('Media', fileBuffer, { contentType: resolvedMimeType });
+
+    const result = await httpClient.sendRequest({
+      method: HttpMethod.POST,
+      url: `https://www.googleapis.com/upload/drive/v3/files`,
+      queryParams: {
+        uploadType: 'multipart',
+        supportsAllDrives: 'true',
+      },
+      body: form,
+      headers: {
+        ...form.getHeaders(),
+      },
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: await getAccessToken(context.auth),
+      },
+    });
+
+    return result.body;
+  },
+});

package/src/lib/action/duplicate-file.action.ts

@@ -0,0 +1,82 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { drive as googleDrive } from '@googleapis/drive';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { common } from '../common';
+import { duplicateFileActionOutputSchema } from '../output-schemas';
+
+export const duplicateFileAction = createAction({
+  displayName: 'Duplicate File',
+  auth: googleDriveAuth,
+  name: 'duplicate_file',
+  description: 'Duplicate a file from Google Drive. Returns the new file ID.',
+  audience: 'human',
+  aiMetadata: { description: 'Copies an existing Drive file into a target folder under a new name, optionally converting it to a Google Sheet or Google Doc. Use to clone a file or create an editable Google-format copy. Requires the source file ID and destination folder ID. Not idempotent: each call creates a new copy.', idempotent: false },
+  props: {
+    fileId: Property.ShortText({
+      displayName: 'File ID',
+      description: 'The ID of the file to duplicate',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'Name',
+      description: 'The name of the new file',
+      required: true,
+    }),
+    folderId: Property.ShortText({
+      displayName: 'Folder ID',
+      description: 'The ID of the folder where the file will be duplicated',
+      required: true,
+    }),
+    mimeType: Property.StaticDropdown({
+      displayName: 'Duplicate as',
+      description: 'If left unselected the file will be duplicated as it is',
+      required: false,
+      options: {
+        options: [
+          {
+            label: 'Google Sheets',
+            value: 'application/vnd.google-apps.spreadsheet',
+          },
+          {
+            label: 'Google Docs',
+            value: 'application/vnd.google-apps.document',
+          }
+        ],
+      },
+    }),
+    include_team_drives: common.properties.include_team_drives,
+  },
+  outputSchema: duplicateFileActionOutputSchema,
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const fileId = context.propsValue.fileId;
+    const nameForNewFile = context.propsValue.name;
+    const parentFolderId = context.propsValue.folderId;
+    const mimeType = context.propsValue.mimeType;
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    const requestBody: any = {
+      name: nameForNewFile,
+      parents: [parentFolderId],
+    };
+
+    if (mimeType) {
+      requestBody.mimeType = mimeType;
+    }
+
+    const response = await drive.files.copy({
+      fileId,
+      auth: authClient,
+      requestBody,
+      supportsAllDrives: context.propsValue.include_team_drives,
+    });
+
+    if (response.status !== 200) {
+      throw new Error('Error duplicating file');
+    }
+
+    return response.data;
+  },
+});

package/src/lib/action/get-file-by-id.ts

@@ -0,0 +1,37 @@
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { drive as googleDrive } from '@googleapis/drive';
+import { common } from '../common';
+import { getFileOrFolderByIdActionOutputSchema } from '../output-schemas';
+
+export const googleDriveGetResourceById = createAction({
+  auth: googleDriveAuth,
+  name: 'get-file-or-folder-by-id',
+  displayName: 'Get File Information',
+  description: 'Get a file folder for files/sub-folders',
+  audience: 'human',
+  aiMetadata: { description: 'Fetches metadata for a single file or folder in Google Drive by its exact ID (name, MIME type, parents, etc.). Use when an agent already has a file/folder ID and needs its details. Read-only and idempotent. Requires the resource ID, not a name or path.', idempotent: true },
+  props: {
+    id: Property.ShortText({
+      displayName: 'File / Folder Id',
+      description: 'The Id of the file/folder to search for.',
+      required: true,
+    }),
+    include_team_drives: common.properties.include_team_drives,
+  },
+  outputSchema: getFileOrFolderByIdActionOutputSchema,
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+    const response = await drive.files.get({
+      fileId: context.propsValue.id,
+      supportsAllDrives: context.propsValue.include_team_drives,
+    });
+
+    if (response.data) {
+      return response.data;
+    } else {
+      return null;
+    }
+  },
+});

package/src/lib/action/list-files.action.ts

@@ -0,0 +1,214 @@
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { googleDriveAuth, getAccessToken } from '../auth';
+import { Property, createAction } from "@agnocon/pieces-framework";
+import querystring from 'querystring';
+import { common } from '../common';
+import { downloadFileFromDrive } from '../common/get-file-content';
+import { listFilesActionOutputSchema } from '../output-schemas';
+
+interface ListFilesResult {
+  type: string;
+  incompleteSearch: boolean;
+  files: unknown[];
+  downloadedFiles?: string[];
+}
+
+interface FileWithLevel {
+  file: any;
+  level: number;
+  parentFolder?: string;
+}
+
+async function getFilesRecursively(
+  auth: any,
+  folderId: string,
+  maxLevel: number,
+  includeTrashed: boolean,
+  includeTeamDrives: boolean,
+  currentLevel = 0
+): Promise<FileWithLevel[]> {
+  const files: FileWithLevel[] = [];
+
+  if (currentLevel > maxLevel) {
+    return files;
+  }
+
+  const accessToken = await getAccessToken(auth);
+
+  let q = `'${folderId}' in parents`;
+  if (!includeTrashed) {
+    q += ' and trashed=false';
+  }
+
+  const params: Record<string, string> = {
+    q: q,
+    fields: 'nextPageToken,files(id,kind,mimeType,name,trashed,parents)',
+    supportsAllDrives: 'true',
+    includeItemsFromAllDrives: includeTeamDrives ? 'true' : 'false',
+    corpora: includeTeamDrives ? 'allDrives' : 'user',
+    pageSize: '1000',
+  };
+
+  let response = await httpClient.sendRequest({
+    method: HttpMethod.GET,
+    url: `https://www.googleapis.com/drive/v3/files?${querystring.stringify(params)}`,
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+  });
+
+  // Add files from current level
+  for (const file of response.body.files) {
+    files.push({
+      file,
+      level: currentLevel,
+      parentFolder: folderId
+    });
+  }
+
+  // Handle pagination for current level
+  while (response.body.nextPageToken) {
+    params.pageToken = response.body.nextPageToken;
+    response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://www.googleapis.com/drive/v3/files?${querystring.stringify(params)}`,
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+
+    for (const file of response.body.files) {
+      files.push({
+        file,
+        level: currentLevel,
+        parentFolder: folderId
+      });
+    }
+  }
+
+  // If we haven't reached max level, recursively get files from subfolders
+  if (currentLevel + 1 < maxLevel) {
+    const subfolders = files.filter(f => f.file.mimeType === 'application/vnd.google-apps.folder');
+
+    for (const subfolder of subfolders) {
+      const subfolderFiles = await getFilesRecursively(
+        auth,
+        subfolder.file.id,
+        maxLevel,
+        includeTrashed,
+        includeTeamDrives,
+        currentLevel + 1
+      );
+      files.push(...subfolderFiles);
+    }
+  }
+
+  return files;
+}
+
+export const googleDriveListFiles = createAction({
+  auth: googleDriveAuth,
+  name: 'list-files',
+  displayName: 'List files',
+  description: 'List files from a Google Drive folder',
+  audience: 'human',
+  aiMetadata: { description: 'Lists files and subfolders inside a given Drive folder, with optional recursion to a chosen depth and optional download of each file\'s content. Use to enumerate the contents of a known folder ID. Read-only and idempotent. Requires the folder ID, not a name.', idempotent: true },
+  props: {
+    folderId: Property.ShortText({
+      displayName: 'Folder ID',
+      description: 'Folder ID coming from | New Folder -> id | (or any other source)',
+      required: true,
+    }),
+    include_team_drives: common.properties.include_team_drives,
+    
+    includeTrashed: Property.Checkbox({
+      displayName: 'Include Trashed',
+      description: 'Include new files that have been trashed.',
+      required: false,
+      defaultValue: false
+    }),
+
+    depthLevel: Property.Number({
+      displayName: 'Depth Level',
+      description: 'How many levels deep to search for files. 1 = current folder only, 2 = current + next level, etc.',
+      required: false,
+      defaultValue: 1
+    }),
+
+    downloadFiles: Property.Checkbox({
+      displayName: 'Download Files',
+      description: 'Download all file contents in a list',
+      required: false,
+      defaultValue: false
+    }),
+  },
+  outputSchema: listFilesActionOutputSchema,
+  async run(context) {
+    const result: ListFilesResult = {
+      type: 'drive#fileList',
+      incompleteSearch: false,
+      files: [],
+    }
+
+    const depthLevel = context.propsValue.depthLevel || 1;
+    
+    // Get files recursively based on depth level
+    const filesWithLevel = await getFilesRecursively(
+      context.auth,
+      context.propsValue.folderId,
+      depthLevel,
+      context.propsValue.includeTrashed ?? false,
+      context.propsValue.include_team_drives ?? false
+    );
+
+    // Extract just the file objects for backward compatibility
+    result.files = filesWithLevel.map(f => f.file);
+
+    // If downloadFiles is enabled, download each file and add URLs to array
+    if (context.propsValue.downloadFiles) {
+      const downloadedFiles: string[] = [];
+      const extensionMap: Record<string, string> = {
+        'application/pdf': '.pdf',
+        'image/jpeg': '.jpg',
+        'image/png': '.png',
+        'image/tiff': '.tiff',
+        'text/plain': '.txt',
+        'text/csv': '.csv',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx'
+      };
+
+      for (const fileWithLevel of filesWithLevel) {
+        const file = fileWithLevel.file;
+        // Skip folders when downloading
+        if (file.mimeType === 'application/vnd.google-apps.folder') {
+          continue;
+        }
+
+        let safeName = file.name;
+        const correctExtension = extensionMap[file.mimeType];
+        if (correctExtension && !safeName.toLowerCase().endsWith(correctExtension)) {
+            // Check for the .jpeg edge case before appending .jpg
+            if (!(file.mimeType === 'image/jpeg' && safeName.toLowerCase().endsWith('.jpeg'))) {
+                safeName = safeName + correctExtension;
+            }
+        }
+        
+        try {
+          const fileUrl = await downloadFileFromDrive(
+            context.auth,
+            context.files,
+            file.id,
+            safeName
+          );
+          downloadedFiles.push(fileUrl);
+        } catch (error) {
+          console.warn(`Failed to download file ${file.name}: ${error instanceof Error ? error.message : 'Download failed'}`);
+        }
+      }
+      result.downloadedFiles = downloadedFiles;
+    }
+
+    return result;
+  }
+});