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

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

@@ -0,0 +1,238 @@
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { googleDriveAuth, getAccessToken } from '../auth';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import querystring from 'querystring';
+import { downloadFileFromDrive } from '../common/get-file-content';
+import { driveListFilesOutputSchema } 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 driveListFiles = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_list_files',
+  displayName: 'List Folder Contents',
+  description: 'List files from a Google Drive folder',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Lists files and subfolders inside a given folder ID, optionally recursing to a chosen depth and downloading each file\'s content. Use to enumerate the contents of a known folder; to find a file by name across Drive use `drive_search_files`. Read-only. Requires the folder ID, not a name.',
+    idempotent: true,
+  },
+  outputSchema: driveListFilesOutputSchema,
+  props: {
+    folder_id: Property.ShortText({
+      displayName: 'Folder ID',
+      description:
+        'The ID of the folder to list. Resolve it via `drive_search_files` (or any other source).',
+      required: true,
+    }),
+    include_trashed: Property.Checkbox({
+      displayName: 'Include Trashed',
+      description: 'Include new files that have been trashed.',
+      required: false,
+      defaultValue: false,
+    }),
+    depth_level: 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,
+    }),
+    download_files: Property.Checkbox({
+      displayName: 'Download Files',
+      description: 'Download all file contents in a list',
+      required: false,
+      defaultValue: false,
+    }),
+    include_team_drives: Property.Checkbox({
+      displayName: 'Include Team Drives',
+      description:
+        'Determines if folders from Team Drives should be included in the results.',
+      defaultValue: false,
+      required: false,
+    }),
+  },
+  async run(context) {
+    const result: ListFilesResult = {
+      type: 'drive#fileList',
+      incompleteSearch: false,
+      files: [],
+    };
+
+    const depthLevel = context.propsValue.depth_level || 1;
+
+    // Get files recursively based on depth level
+    const filesWithLevel = await getFilesRecursively(
+      context.auth,
+      context.propsValue.folder_id,
+      depthLevel,
+      context.propsValue.include_trashed ?? 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.download_files) {
+      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;
+  },
+});

package/src/lib/action/drive-list-permissions.ts

@@ -0,0 +1,60 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveListPermissionsOutputSchema } from '../output-schemas';
+
+export const driveListPermissions = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_list_permissions',
+  displayName: 'List Permissions',
+  description: 'List every permission on a Drive file or folder.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Lists every permission (who has access and at what role) on a file or folder, with each permission\'s id, type, role, and email/domain. Use to audit sharing before granting or revoking; it is the resolver for the permissionId other sharing atomics need. Read-only.',
+    idempotent: true,
+  },
+  outputSchema: driveListPermissionsOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File or Folder ID',
+      description:
+        'The ID of the file or folder whose permissions to list. Resolve it via drive_search_files or drive_get_file.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { file_id } = context.propsValue;
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    try {
+      const response = await drive.permissions.list({
+        fileId: file_id,
+        fields: 'permissions(id,type,role,emailAddress,domain)',
+        supportsAllDrives: true,
+      });
+
+      const permissions = response.data.permissions ?? [];
+
+      return {
+        permissions,
+        count: permissions.length,
+      };
+    } catch (error: any) {
+      if (error.code === 404) {
+        throw new Error(
+          `File or folder not found (ID: ${file_id}). Resolve a valid ID via drive_search_files or drive_get_file.`
+        );
+      }
+      if (error.code === 403) {
+        throw new Error(
+          `Permission denied listing permissions for file ${file_id}. You may lack access to this resource.`
+        );
+      }
+      throw error;
+    }
+  },
+});

package/src/lib/action/drive-list-replies.ts

@@ -0,0 +1,66 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveListRepliesOutputSchema } from '../output-schemas';
+
+export const driveListReplies = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_list_replies',
+  displayName: 'List Replies',
+  description: 'List the replies under a Drive comment.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Lists the replies under a given comment with each reply\'s id, author, content, and action. Use to read a comment thread or to resolve a replyId before fetching (drive_get_reply), editing (drive_update_reply), or deleting (drive_delete_reply) a reply. Read-only.',
+    idempotent: true,
+  },
+  outputSchema: driveListRepliesOutputSchema,
+  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 comment whose replies to list. Resolve it via drive_list_comments.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { file_id, comment_id } = 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.list({
+        fileId: file_id,
+        commentId: comment_id,
+        fields: '*',
+      });
+
+      const replies = response.data.replies ?? [];
+
+      return {
+        replies,
+        count: replies.length,
+      };
+    } catch (error: any) {
+      if (error.code === 404) {
+        throw new Error(
+          `File or comment not found (file ID: ${file_id}, comment ID: ${comment_id}). Resolve the comment ID via drive_list_comments.`
+        );
+      }
+      if (error.code === 403) {
+        throw new Error(
+          `Permission denied listing replies for comment ${comment_id} on file ${file_id}. You may lack access to this file.`
+        );
+      }
+      throw error;
+    }
+  },
+});

package/src/lib/action/drive-list-shared-drives.ts

@@ -0,0 +1,59 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveListSharedDrivesOutputSchema } from '../output-schemas';
+
+export const driveListSharedDrives = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_list_shared_drives',
+  displayName: 'List Shared Drives',
+  description: 'List the shared drives the account can access.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Lists the shared drives the account can access, with each drive\'s id and name. Use to discover a driveId before creating or listing content in a shared drive or before drive_get_shared_drive, drive_update_shared_drive, or drive_delete_shared_drive. Read-only.',
+    idempotent: true,
+  },
+  outputSchema: driveListSharedDrivesOutputSchema,
+  props: {
+    query: Property.ShortText({
+      displayName: 'Query',
+      description:
+        'Optional search query to filter shared drives, e.g. name contains \'marketing\'. See https://developers.google.com/drive/api/guides/search-shareddrives',
+      required: false,
+    }),
+    page_size: Property.Number({
+      displayName: 'Page Size',
+      description: 'Maximum number of shared drives to return (1-100). Defaults to 100.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const { query, page_size } = context.propsValue;
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    try {
+      const response = await drive.drives.list({
+        q: query || undefined,
+        pageSize: page_size || undefined,
+      });
+
+      const drives = response.data.drives ?? [];
+
+      return {
+        drives,
+        count: drives.length,
+      };
+    } catch (error: any) {
+      if (error.code === 403) {
+        throw new Error(
+          'Permission denied listing shared drives. Your account may not have shared-drive access.'
+        );
+      }
+      throw error;
+    }
+  },
+});

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

@@ -0,0 +1,56 @@
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveMoveFileOutputSchema } from '../output-schemas';
+
+export const driveMoveFile = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_move_file',
+  displayName: 'Move File',
+  description: 'Move a Drive file from its current folder(s) to a target folder.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Relocates a file to a target folder, detaching it from its current parents and attaching the new one. Use to reorganize a file by ID; to copy instead of move use drive_copy_file, and to rename without moving use drive_update_file_metadata. Safe to retry — repeating leaves the file in the same destination.',
+    idempotent: true,
+  },
+  outputSchema: driveMoveFileOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File ID',
+      description:
+        'The ID of the file to move. Resolve it via drive_search_files or drive_get_file.',
+      required: true,
+    }),
+    folder_id: Property.ShortText({
+      displayName: 'Destination Folder ID',
+      description:
+        'The ID of the folder to move the file into. Resolve it via drive_search_files; leave empty for the root of My Drive.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const fileId = context.propsValue.file_id;
+    const folderId = context.propsValue.folder_id;
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    const file = await drive.files.get({
+      fileId,
+      supportsAllDrives: true,
+      fields: 'id,parents',
+    });
+
+    const response = await drive.files.update({
+      fileId: fileId,
+      fields: '*',
+      removeParents: file.data.parents?.join(','),
+      addParents: folderId,
+      supportsAllDrives: true,
+    });
+
+    return response.data;
+  },
+});

package/src/lib/action/drive-remove-permission.ts

@@ -0,0 +1,75 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveRemovePermissionOutputSchema } from '../output-schemas';
+
+export const driveRemovePermission = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_remove_permission',
+  displayName: 'Remove Permission',
+  description: 'Revoke a role from a user on a Drive file or folder.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Revokes a specific role from a user (matched by email and role) on a file or folder, resolving the permission ID internally. Use to unshare or remove access; to lower a role instead of removing it use drive_update_permission. Safe to retry — if no matching permission exists it is a no-op.',
+    idempotent: true,
+  },
+  outputSchema: driveRemovePermissionOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File or Folder ID',
+      description:
+        'The ID of the file or folder to remove the permission from. Resolve it via drive_search_files or drive_get_file.',
+      required: true,
+    }),
+    user_email: Property.ShortText({
+      displayName: 'User Email',
+      description: 'The email address of the user whose access to revoke.',
+      required: true,
+    }),
+    role: Property.StaticDropdown({
+      displayName: 'Role',
+      description: 'The role to remove from the user. The grant is matched by email and role.',
+      required: true,
+      options: {
+        options: [
+          { label: 'Organizer', value: 'organizer' },
+          { label: 'File Organizer', value: 'fileOrganizer' },
+          { label: 'Writer', value: 'writer' },
+          { label: 'Commenter', value: 'commenter' },
+          { label: 'Reader', value: 'reader' },
+        ],
+      },
+    }),
+  },
+  async run(context) {
+    const [file_id, user_email] = [context.propsValue.file_id, context.propsValue.user_email];
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    const response_permissions_list = await drive.permissions.list({
+      fileId: file_id,
+      fields: 'permissions(id, emailAddress, role)',
+      supportsAllDrives: true,
+    });
+
+    if (response_permissions_list.data.permissions) {
+      for (const permission of response_permissions_list.data.permissions) {
+        if (
+          permission.emailAddress === user_email &&
+          permission.role === context.propsValue.role
+        ) {
+          await drive.permissions.delete({
+            fileId: file_id,
+            permissionId: permission.id ? permission.id : '',
+            supportsAllDrives: true,
+          });
+          return { removed: true, message: 'Permission removed' };
+        }
+      }
+    }
+
+    return { removed: false, message: 'Permission not found' };
+  },
+});

package/src/lib/action/drive-replace-file-content.ts

@@ -0,0 +1,71 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import {
+  httpClient,
+  HttpMethod,
+  AuthenticationType,
+} from '@agnocon/pieces-common';
+import { googleDriveAuth, getAccessToken } from '../auth';
+import mime from 'mime-types';
+import { driveReplaceFileContentOutputSchema } from '../output-schemas';
+
+export const driveReplaceFileContent = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_replace_file_content',
+  displayName: 'Replace File Content',
+  description: "Replace an existing Drive file's bytes, keeping its ID and name.",
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      "Replaces the contents of an existing Drive file with new bytes, keeping the same file ID, name, and location. Use to update a file in place (e.g. overwrite a report); to create a brand-new file use `drive_upload_file`, and to rename without changing content use `drive_update_file_metadata`. Each call overwrites the previous content.",
+    idempotent: false,
+  },
+  outputSchema: driveReplaceFileContentOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File ID',
+      description:
+        'The ID of the existing file whose content to replace. Resolve it via `drive_search_files` or `drive_get_file`.',
+      required: true,
+    }),
+    file: Property.File({
+      displayName: 'New File Content',
+      description: 'The file URL or base64 whose bytes will replace the existing content.',
+      required: true,
+    }),
+    mime_type: Property.ShortText({
+      displayName: 'MIME Type',
+      description:
+        'Optional MIME type for the new content (e.g. application/pdf). Provide this when the source has no file extension; otherwise the type is inferred from the extension.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const { file_id, file, mime_type } = context.propsValue;
+
+    const resolvedMimeType =
+      mime_type ||
+      mime.lookup(file.extension ? file.extension : '') ||
+      'application/octet-stream';
+
+    const fileBuffer = Buffer.from(file.base64, 'base64');
+
+    const result = await httpClient.sendRequest({
+      method: HttpMethod.PATCH,
+      url: `https://www.googleapis.com/upload/drive/v3/files/${file_id}`,
+      queryParams: {
+        uploadType: 'media',
+        supportsAllDrives: 'true',
+      },
+      body: fileBuffer,
+      headers: {
+        'Content-Type': resolvedMimeType,
+      },
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: await getAccessToken(context.auth),
+      },
+    });
+
+    return result.body;
+  },
+});