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

package/src/lib/action/create-new-folder.ts

@@ -0,0 +1,42 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { common } from '../common';
+import { drive as googleDrive } from '@googleapis/drive';
+import { createNewGdriveFolderActionOutputSchema } from '../output-schemas';
+
+export const googleDriveCreateNewFolder = createAction({
+  auth: googleDriveAuth,
+  name: 'create_new_gdrive_folder',
+  description: 'Create a new empty folder in your Google Drive',
+  audience: 'human',
+  aiMetadata: { description: 'Creates a new empty folder in Google Drive, optionally nested under a parent folder. Use to set up a destination before uploading or moving files. Not idempotent: each call creates a distinct folder even with the same name (Drive permits duplicate folder names).', idempotent: false },
+  displayName: 'Create new folder',
+  props: {
+    folderName: Property.ShortText({
+      displayName: 'Folder name',
+      description: 'The name of the new folder',
+      required: true,
+    }),
+    parentFolder: common.properties.parentFolder,
+    include_team_drives: common.properties.include_team_drives,
+  },
+  outputSchema: createNewGdriveFolderActionOutputSchema,
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    const response = await drive.files.create({
+      requestBody: {
+        mimeType: 'application/vnd.google-apps.folder',
+        name: context.propsValue.folderName,
+        ...(context.propsValue.parentFolder
+          ? { parents: [context.propsValue.parentFolder] }
+          : {}),
+      },
+      supportsAllDrives: context.propsValue.include_team_drives,
+    });
+
+    return response.data;
+  },
+});

package/src/lib/action/create-new-text-file.ts

@@ -0,0 +1,80 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { drive as googleDrive } from '@googleapis/drive';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { common } from '../common';
+import { createNewGdriveFileActionOutputSchema } from '../output-schemas';
+
+export const googleDriveCreateNewTextFile = createAction({
+  auth: googleDriveAuth,
+  name: 'create_new_gdrive_file',
+  description: 'Create a new text file in your Google Drive from text',
+  audience: 'human',
+  aiMetadata: { description: 'Creates a new file in Google Drive from inline text content as plain text, CSV, or XML, optionally inside a parent folder. Use when an agent has generated text it needs to persist as a Drive file. Not idempotent: each call creates a new file.', idempotent: false },
+  displayName: 'Create new file',
+  props: {
+    fileName: Property.ShortText({
+      displayName: 'File name',
+      description: 'The name of the new text file',
+      required: true,
+    }),
+    text: Property.LongText({
+      displayName: 'Text',
+      description: 'The text content to add to file',
+      required: true,
+    }),
+    fileType: Property.StaticDropdown({
+      displayName: 'Content type',
+      description: 'Select file type',
+      required: true,
+      defaultValue: 'text/plain',
+      options: {
+        options: [
+          {
+            label: 'Text',
+            value: 'text/plain',
+          },
+          {
+            label: 'CSV',
+            value: 'text/csv',
+          },
+          {
+            label: 'XML',
+            value: 'text/xml',
+          },
+        ],
+      },
+    }),
+    parentFolder: common.properties.parentFolder,
+    include_team_drives: common.properties.include_team_drives,
+  },
+  outputSchema: createNewGdriveFileActionOutputSchema,
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    // Normalize the legacy 'plain/text' value saved by existing flows to the
+    // valid 'text/plain' MIME type Google Drive expects.
+    const mimeType =
+      context.propsValue.fileType === 'plain/text'
+        ? 'text/plain'
+        : context.propsValue.fileType;
+
+    const response = await drive.files.create({
+      requestBody: {
+        name: context.propsValue.fileName,
+        mimeType,
+        ...(context.propsValue.parentFolder
+          ? { parents: [context.propsValue.parentFolder] }
+          : {}),
+      },
+      media: {
+        mimeType,
+        body: context.propsValue.text,
+      },
+      supportsAllDrives: context.propsValue.include_team_drives ?? false,
+      fields: 'id, name, mimeType, kind',
+    });
+
+    return response.data;
+  },
+});

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

@@ -0,0 +1,33 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { common } from '../common';
+import { drive as googleDrive } from '@googleapis/drive';
+
+export const googleDriveDeleteFile = createAction({
+  auth: googleDriveAuth,
+  name: 'delete_gdrive_file',
+  description: 'Delete permanently a file from your Google Drive',
+  audience: 'human',
+  aiMetadata: { description: 'Permanently deletes a file from Google Drive by its ID, bypassing the trash and making it unrecoverable. Use only when permanent removal is intended; prefer Trash file for reversible deletion. Requires the file ID. Not idempotent: a repeat call fails because the file no longer exists.', idempotent: false },
+  displayName: 'Delete file',
+  props: {
+    fileId: Property.ShortText({
+      displayName: 'File ID',
+      description: 'The ID of the file to delete',
+      required: true,
+    }),
+    include_team_drives: common.properties.include_team_drives,
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    const response = await drive.files.delete({
+      fileId: context.propsValue.fileId,
+      supportsAllDrives: context.propsValue.include_team_drives,
+    });
+
+    return response.data;
+  },
+});

package/src/lib/action/delete-permission.action.ts

@@ -0,0 +1,84 @@
+import { Property, createAction } from "@agnocon/pieces-framework";
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { deletePermissionsActionOutputSchema } from '../output-schemas';
+
+export const deletePermission = createAction({
+    auth: googleDriveAuth,
+    name: 'delete_permissions',
+    description: 'Removes a role from an user for a file or folder',
+    audience: 'human',
+    aiMetadata: { description: 'Revokes a specific role from a user (matched by email and role) on a Drive file or folder. Use to unshare or downgrade access for someone. Requires the file/folder ID, the user email, and the role to remove. Idempotent: if no matching permission exists, the call is a no-op.', idempotent: true },
+    displayName: 'Delete permissions',
+    props: {
+        fileId: Property.ShortText({
+            displayName: 'File or Folder ID',
+            description: 'The ID of the file or folder to update permissions for',
+            required: true,
+        }),
+        user_email: Property.ShortText({
+            displayName: 'User email',
+            description: 'The email address of the user to update permissions for',
+            required: true,
+        }),  
+        permission_name : Property.StaticDropdown({
+            displayName: 'Role',
+            description: 'The role to remove from user.',
+            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',
+                },
+                
+            ]
+            }
+        }),
+    },
+    outputSchema: deletePermissionsActionOutputSchema,
+    async run (context) {
+        const [fileId, user_email] = [context.propsValue.fileId, 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: fileId,
+            fields: 'permissions(id, emailAddress, role)',
+            
+        });
+
+        if (response_permissions_list.data.permissions) {
+
+            for (const permission of response_permissions_list.data.permissions) {
+                if (permission.emailAddress === user_email && permission.role === context.propsValue.permission_name) {
+                    await drive.permissions.delete({
+                        fileId: fileId,
+                        permissionId: permission.id ? permission.id : '',
+                    });
+                    return {removed: true, message: 'Permission removed'};
+                }
+            }
+        }
+
+        return {removed: false, message: 'Permission not found'};        
+
+    }
+});

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

@@ -0,0 +1,86 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { drive as googleDrive } from '@googleapis/drive';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { driveCopyFileOutputSchema } from '../output-schemas';
+
+export const driveCopyFile = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_copy_file',
+  displayName: 'Copy File',
+  description: 'Duplicate a file from Google Drive. Returns the new file ID.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Copies an existing Drive file into a target folder under a new name, optionally converting it to a Google Sheet or Doc. Use to clone a file or make an editable Google-format copy; to relocate the original instead of copying use `drive_move_file`. Requires source file ID and destination folder ID. Each call creates a new copy.',
+    idempotent: false,
+  },
+  outputSchema: driveCopyFileOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File ID',
+      description:
+        'The ID of the file to duplicate. Resolve it via `drive_search_files`.',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'Name',
+      description: 'The name of the new file',
+      required: true,
+    }),
+    folder_id: Property.ShortText({
+      displayName: 'Folder ID',
+      description:
+        'The ID of the folder where the file will be duplicated. Resolve it via `drive_search_files`.',
+      required: true,
+    }),
+    convert_to: 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',
+          },
+        ],
+      },
+    }),
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const fileId = context.propsValue.file_id;
+    const nameForNewFile = context.propsValue.name;
+    const parentFolderId = context.propsValue.folder_id;
+    const mimeType = context.propsValue.convert_to;
+
+    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: true,
+    });
+
+    if (response.status !== 200) {
+      throw new Error('Error duplicating file');
+    }
+
+    return response.data;
+  },
+});

package/src/lib/action/drive-create-comment.ts

@@ -0,0 +1,61 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveCreateCommentOutputSchema } from '../output-schemas';
+
+export const driveCreateComment = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_create_comment',
+  displayName: 'Create Comment',
+  description: 'Add a new comment to a Drive file.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Adds a new top-level comment to a file. Use to leave feedback or a note on a file (resolve the file ID via drive_search_files); to respond to an existing comment use drive_create_reply instead. Each call creates a new comment, so retries duplicate.',
+    idempotent: false,
+  },
+  outputSchema: driveCreateCommentOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File ID',
+      description:
+        'The ID of the file to comment on. Resolve it via drive_search_files or drive_get_file.',
+      required: true,
+    }),
+    content: Property.LongText({
+      displayName: 'Content',
+      description: 'The plain-text content of the comment.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { file_id, content } = context.propsValue;
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    try {
+      // The Drive comments endpoints require a fields parameter or the API returns 400.
+      const response = await drive.comments.create({
+        fileId: file_id,
+        fields: '*',
+        requestBody: { content },
+      });
+
+      return response.data;
+    } catch (error: any) {
+      if (error.code === 404) {
+        throw new Error(
+          `File 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 commenting on file ${file_id}. You may lack comment access to this file.`
+        );
+      }
+      throw error;
+    }
+  },
+});

package/src/lib/action/drive-create-file-from-text.ts

@@ -0,0 +1,99 @@
+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 { driveCreateFileFromTextOutputSchema } from '../output-schemas';
+
+export const driveCreateFileFromText = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_create_file_from_text',
+  displayName: 'Create File from Text',
+  description: 'Create a new text file in your Google Drive from text',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Creates a new Drive file from inline text content as plain text, CSV, or XML. Use when an agent has generated text it needs to persist as a Drive file; for binary or existing files use `drive_upload_file` instead. Each call creates a new file.',
+    idempotent: false,
+  },
+  outputSchema: driveCreateFileFromTextOutputSchema,
+  props: {
+    file_name: Property.ShortText({
+      displayName: 'File name',
+      description: 'The name of the new text file',
+      required: true,
+    }),
+    text: Property.LongText({
+      displayName: 'Text',
+      description: 'The text content to add to file',
+      required: true,
+    }),
+    content_type: Property.StaticDropdown({
+      displayName: 'Content type',
+      description: 'Select file type',
+      required: true,
+      defaultValue: 'plain/text',
+      options: {
+        options: [
+          {
+            label: 'Text',
+            value: 'plain/text',
+          },
+          {
+            label: 'CSV',
+            value: 'text/csv',
+          },
+          {
+            label: 'XML',
+            value: 'text/xml',
+          },
+        ],
+      },
+    }),
+    parent_folder_id: Property.ShortText({
+      displayName: 'Parent Folder ID',
+      description:
+        'The ID of the folder to create the file inside. Leave empty to create it in the root of My Drive. Resolve a folder ID with `drive_search_files`.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const meta = {
+      mimeType: context.propsValue.content_type,
+      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 textBuffer = Buffer.from(context.propsValue.text!, 'utf-8');
+
+    const form = new FormData();
+    form.append('Metadata', metaBuffer, { contentType: 'application/json' });
+    form.append('Media', textBuffer, {
+      contentType: context.propsValue.content_type,
+    });
+
+    const result = await httpClient.sendRequest({
+      method: HttpMethod.POST,
+      url: `https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart`,
+      body: form,
+      headers: {
+        ...form.getHeaders(),
+      },
+      queryParams: {
+        supportsAllDrives: 'true',
+      },
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: await getAccessToken(context.auth),
+      },
+    });
+
+    return result.body;
+  },
+});

package/src/lib/action/drive-create-folder.ts

@@ -0,0 +1,49 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveCreateFolderOutputSchema } from '../output-schemas';
+
+export const driveCreateFolder = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_create_folder',
+  displayName: 'Create Folder',
+  description: 'Create a new empty folder in your Google Drive',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Creates a new empty folder in Google Drive, optionally nested under a parent folder (resolve the parent ID via `drive_search_files`). Use to set up a destination before uploading or moving files. Each call creates a distinct folder even with the same name, so retries duplicate.',
+    idempotent: false,
+  },
+  outputSchema: driveCreateFolderOutputSchema,
+  props: {
+    folder_name: Property.ShortText({
+      displayName: 'Folder name',
+      description: 'The name of the new folder',
+      required: true,
+    }),
+    parent_folder_id: Property.ShortText({
+      displayName: 'Parent Folder ID',
+      description:
+        'The ID of the folder to create the new folder inside. Leave empty to create it in the root of My Drive. Resolve a folder ID with `drive_search_files`.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    const response = await drive.files.create({
+      requestBody: {
+        mimeType: 'application/vnd.google-apps.folder',
+        name: context.propsValue.folder_name,
+        ...(context.propsValue.parent_folder_id
+          ? { parents: [context.propsValue.parent_folder_id] }
+          : {}),
+      },
+      supportsAllDrives: true,
+    });
+
+    return response.data;
+  },
+});

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

@@ -0,0 +1,84 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveCreateReplyOutputSchema } from '../output-schemas';
+
+export const driveCreateReply = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_create_reply',
+  displayName: 'Reply to Comment',
+  description: 'Add a reply to an existing comment on a Drive file.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Adds a reply to an existing comment, optionally resolving or reopening the comment via the action field. Use to respond to a comment (resolve the commentId via drive_list_comments); to start a new top-level comment use drive_create_comment instead. Each call creates a new reply, so retries duplicate.',
+    idempotent: false,
+  },
+  outputSchema: driveCreateReplyOutputSchema,
+  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 to reply to. Resolve it via drive_list_comments.',
+      required: true,
+    }),
+    content: Property.LongText({
+      displayName: 'Content',
+      description: 'The plain-text content of the reply.',
+      required: true,
+    }),
+    action: Property.StaticDropdown({
+      displayName: 'Action',
+      description:
+        'Optionally change the parent comment\'s state: resolve (mark resolved) or reopen.',
+      required: false,
+      options: {
+        options: [
+          { label: 'Resolve', value: 'resolve' },
+          { label: 'Reopen', value: 'reopen' },
+        ],
+      },
+    }),
+  },
+  async run(context) {
+    const { file_id, comment_id, content, action } = context.propsValue;
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    const requestBody: { content: string; action?: string } = { content };
+    if (action) {
+      requestBody.action = action;
+    }
+
+    try {
+      // The Drive replies endpoints require a fields parameter or the API returns 400.
+      const response = await drive.replies.create({
+        fileId: file_id,
+        commentId: comment_id,
+        fields: '*',
+        requestBody,
+      });
+
+      return response.data;
+    } 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 replying to comment ${comment_id} on file ${file_id}. You may lack comment access to this file.`
+        );
+      }
+      throw error;
+    }
+  },
+});

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

@@ -0,0 +1,52 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { randomUUID } from 'crypto';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveCreateSharedDriveOutputSchema } from '../output-schemas';
+
+export const driveCreateSharedDrive = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_create_shared_drive',
+  displayName: 'Create Shared Drive',
+  description: 'Create a new shared drive (Team Drive).',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Creates a new shared drive (Team Drive) with the given name; the action supplies the required idempotency requestId internally. Use to set up a shared workspace. Each call creates a distinct shared drive. Your Workspace admin must have shared-drive creation enabled (a 403 here is an admin-policy issue, not a scope issue).',
+    idempotent: false,
+  },
+  outputSchema: driveCreateSharedDriveOutputSchema,
+  props: {
+    name: Property.ShortText({
+      displayName: 'Name',
+      description: 'The name of the new shared drive.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { name } = context.propsValue;
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    // drives.create requires a requestId (idempotency key); omitting it returns a 400.
+    const requestId = randomUUID();
+
+    try {
+      const response = await drive.drives.create({
+        requestId,
+        requestBody: { name },
+      });
+
+      return response.data;
+    } catch (error: any) {
+      if (error.code === 403) {
+        throw new Error(
+          'Permission denied creating a shared drive. Your Google Workspace admin may have disabled shared-drive creation for your account.'
+        );
+      }
+      throw error;
+    }
+  },
+});