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

package/src/lib/action/drive-save-file-as-pdf.ts

@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { drive as googleDrive } from '@googleapis/drive';
+import { Stream } from 'stream';
+import { driveSaveFileAsPdfOutputSchema } from '../output-schemas';
+
+export const driveSaveFileAsPdf = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_save_file_as_pdf',
+  displayName: 'Save File as PDF',
+  description: 'Save a document as PDF in a Google Drive folder',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Exports a native Google document to PDF and saves it as a new file in a target Drive folder. Use to produce a PDF rendition of a Google Doc/Sheet/Slides for sharing or archival (resolve the source and folder IDs via `drive_search_files`). Each call creates a new PDF file.',
+    idempotent: false,
+  },
+  outputSchema: driveSaveFileAsPdfOutputSchema,
+  props: {
+    document_id: Property.ShortText({
+      displayName: 'Document ID',
+      description:
+        'The ID of the document to export. Resolve it via `drive_search_files`.',
+      required: true,
+    }),
+    folder_id: Property.ShortText({
+      displayName: 'Folder ID',
+      description:
+        'The ID of the folder where the file will be exported. Resolve it via `drive_search_files`.',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'Name',
+      description: 'The name of the new file (do not include the extension)',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const documentId = context.propsValue.document_id;
+    const folderId = context.propsValue.folder_id;
+    const nameForNewFile = context.propsValue.name;
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    const result = await drive.files.export(
+      {
+        fileId: documentId,
+        mimeType: 'application/pdf',
+      },
+      {
+        responseType: 'arraybuffer',
+      }
+    );
+
+    const requestBody = {
+      name: nameForNewFile + '.pdf',
+      parents: [folderId],
+    };
+    const templateBuffer = Buffer.from(result.data as any, 'base64');
+
+    const stream = new Stream.PassThrough().end(templateBuffer);
+
+    const media = {
+      mimeType: 'application/pdf',
+      body: stream,
+    };
+
+    const file = await drive.files.create({
+      requestBody,
+      media: media,
+      supportsAllDrives: true,
+    });
+
+    return file.data;
+  },
+});

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

@@ -0,0 +1,127 @@
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveSearchFilesOutputSchema } from '../output-schemas';
+
+export const driveSearchFiles = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_search_files',
+  displayName: 'Search Files and Folders',
+  description: 'Search a Google Drive folder for files/sub-folders',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Searches Drive for files or folders matching a name, full-text, or MIME-type query, optionally scoped to a parent folder. Use this to resolve a human-readable name into a file/folder ID before acting on it; to list a known folder\'s children use `drive_list_files` instead. Read-only.',
+    idempotent: true,
+  },
+  outputSchema: driveSearchFilesOutputSchema,
+  props: {
+    query_term: Property.StaticDropdown({
+      displayName: 'Query Term',
+      description: 'The Query term or field of file/folder to search upon.',
+      defaultValue: 'name',
+      options: {
+        options: [
+          { label: 'File name', value: 'name' },
+          { label: 'Full text search', value: 'fullText' },
+          { label: 'Content type', value: 'mimeType' },
+        ],
+      },
+      required: true,
+    }),
+    operator: Property.StaticDropdown({
+      displayName: 'Operator',
+      description: 'The operator to create criteria.',
+      required: true,
+      options: {
+        options: [
+          { label: 'Contains', value: 'contains' },
+          { label: 'Equals', value: '=' },
+        ],
+      },
+      defaultValue: 'contains',
+    }),
+    value: Property.ShortText({
+      displayName: 'Value',
+      description: 'Value of the field of file/folder to search for.',
+      required: true,
+    }),
+    type: Property.StaticDropdown({
+      displayName: 'File Type',
+      description: '(Optional) Choose between files and folders.',
+      required: false,
+      options: {
+        options: [
+          { label: 'All', value: 'all' },
+          { label: 'Files', value: 'file' },
+          { label: 'Folders', value: 'folder' },
+        ],
+      },
+      defaultValue: 'all',
+    }),
+    parent_folder_id: Property.ShortText({
+      displayName: 'Parent Folder ID',
+      description:
+        '(Optional) Restrict the search to files/folders inside this folder ID.',
+      required: 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 authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+    const operator = context.propsValue.operator ?? 'contains';
+    const queryTerm = context.propsValue.query_term ?? 'name';
+    let finalQuery = `${queryTerm} ${operator} '${context.propsValue.value}'`;
+    if (context.propsValue.parent_folder_id) {
+      finalQuery = `${finalQuery} and '${context.propsValue.parent_folder_id}' in parents`;
+    }
+
+    const type = context.propsValue.type ?? 'all';
+    switch (type) {
+      case 'file':
+        finalQuery = `${finalQuery} and mimeType!='application/vnd.google-apps.folder'`;
+        break;
+      case 'folder':
+        finalQuery = `${finalQuery} and mimeType='application/vnd.google-apps.folder'`;
+        break;
+      default:
+        break;
+    }
+
+    const allFiles: any[] = [];
+    let pageToken: string | undefined = undefined;
+    do {
+      const listParams: Record<string, any> = {
+        q: finalQuery,
+        fields:
+          'nextPageToken, files(id, name, mimeType, createdTime, modifiedTime)',
+        includeItemsFromAllDrives: context.propsValue.include_team_drives,
+        supportsAllDrives: true,
+        corpora: context.propsValue.include_team_drives ? 'allDrives' : 'user',
+        pageSize: 1000,
+      };
+      if (pageToken) listParams.pageToken = pageToken;
+      const response = await drive.files.list(listParams);
+      if (response.status !== 200) {
+        console.error(response);
+        throw new Error('Error searching for the file/folder');
+      }
+      allFiles.push(...(response.data.files ?? []));
+      pageToken = response.data.nextPageToken ?? undefined;
+    } while (pageToken);
+
+    if (allFiles.length > 0) {
+      return allFiles;
+    } else {
+      return [];
+    }
+  },
+});

package/src/lib/action/drive-set-public-access.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 { downloadFileFromDrive } from '../common/get-file-content';
+import { driveSetPublicAccessOutputSchema } from '../output-schemas';
+
+export const driveSetPublicAccess = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_set_public_access',
+  displayName: 'Set Public Access',
+  description: 'Make a Drive file or folder accessible to anyone with the link.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Makes a file or folder accessible to anyone with the link at the chosen role and returns its shareable view/download URL. Use to publish a resource publicly; to share with a named person instead use drive_share_file. Each call adds a new anyone-with-link permission.',
+    idempotent: false,
+  },
+  outputSchema: driveSetPublicAccessOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File or Folder ID',
+      description:
+        'The ID of the file or folder to make public. Resolve it via drive_search_files or drive_get_file.',
+      required: true,
+    }),
+    role: Property.StaticDropdown({
+      displayName: 'Role',
+      description: 'The role to assign for public access.',
+      options: {
+        options: [
+          { label: 'Reader', value: 'reader' },
+          { label: 'Commenter', value: 'commenter' },
+          { label: 'Editor', value: 'writer' },
+        ],
+      },
+      defaultValue: 'reader',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const fileId = context.propsValue.file_id;
+    const role = context.propsValue.role;
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+    const permission = {
+      role,
+      type: 'anyone',
+    };
+    const res = await drive.permissions.create({
+      fileId: fileId,
+      requestBody: permission,
+      supportsAllDrives: true,
+    });
+
+    const file = await drive.files.get({
+      fileId: fileId,
+      fields: 'name,mimeType,webContentLink,webViewLink',
+      supportsAllDrives: true,
+    });
+
+    if (file.data.mimeType === 'application/vnd.google-apps.folder') {
+      return { ...res.data, webViewLink: file.data.webViewLink, downloadUrl: null };
+    }
+
+    const content = await downloadFileFromDrive(
+      context.auth,
+      context.files,
+      fileId,
+      file.data.name!
+    );
+    return { ...res.data, downloadUrl: content };
+  },
+});

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

@@ -0,0 +1,69 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveShareFileOutputSchema } from '../output-schemas';
+
+export const driveShareFile = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_share_file',
+  displayName: 'Share File with User',
+  description: 'Grant a role on a Drive file or folder to a user by email.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Grants a role to a user (by email) on a file or folder, optionally emailing them. Use to share with a specific person; to share with anyone-with-the-link use drive_set_public_access, and to change an existing collaborator\'s role use drive_update_permission. Each call creates a new permission grant.',
+    idempotent: false,
+  },
+  outputSchema: driveShareFileOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File or Folder ID',
+      description:
+        'The ID of the file or folder to share. 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 to grant access to.',
+      required: true,
+    }),
+    role: Property.StaticDropdown({
+      displayName: 'Role',
+      description:
+        'The role to grant to the user. See https://developers.google.com/drive/api/guides/ref-roles',
+      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' },
+        ],
+      },
+    }),
+    send_invitation_email: Property.Checkbox({
+      displayName: 'Send Invitation Email',
+      description: 'Send an email to the user to notify them of the new permission.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { file_id, user_email, role, send_invitation_email } = context.propsValue;
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    const permission = { type: 'user', role: role, emailAddress: user_email };
+
+    const result = await drive.permissions.create({
+      requestBody: permission,
+      fileId: file_id,
+      sendNotificationEmail: send_invitation_email,
+      supportsAllDrives: true,
+    });
+
+    return result.data;
+  },
+});

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

@@ -0,0 +1,41 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveTrashFileOutputSchema } from '../output-schemas';
+
+export const driveTrashFile = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_trash_file',
+  displayName: 'Trash File',
+  description: 'Move a Drive file to the trash by ID (reversible deletion).',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Moves a file to the trash by ID — a reversible deletion restorable from Drive. Use for safe removal; for irreversible removal use drive_delete_file, and to restore use drive_untrash_file. Safe to retry — re-trashing leaves it trashed.',
+    idempotent: true,
+  },
+  outputSchema: driveTrashFileOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File ID',
+      description:
+        'The ID of the file to trash. Resolve it via drive_search_files or drive_get_file.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+    const body_value = {
+      trashed: true,
+    };
+    const response = await drive.files.update({
+      fileId: context.propsValue.file_id,
+      supportsAllDrives: true,
+      requestBody: body_value,
+    });
+
+    return response.data;
+  },
+});

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

@@ -0,0 +1,54 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveUntrashFileOutputSchema } from '../output-schemas';
+
+export const driveUntrashFile = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_untrash_file',
+  displayName: 'Restore File from Trash',
+  description: 'Restore a trashed Drive file by ID back to its original location.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Restores a trashed file by ID back to its original location. Use to undo a `drive_trash_file`; to permanently purge instead use `drive_empty_trash` or `drive_delete_file`. Safe to retry — re-restoring an active file is a no-op.',
+    idempotent: true,
+  },
+  outputSchema: driveUntrashFileOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File ID',
+      description:
+        'The ID of the trashed file to restore. 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.files.update({
+        fileId: file_id,
+        supportsAllDrives: true,
+        requestBody: { trashed: false },
+      });
+
+      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 restoring file ${file_id}. You may lack permission to restore this resource.`
+        );
+      }
+      throw error;
+    }
+  },
+});

package/src/lib/action/drive-update-file-metadata.ts

@@ -0,0 +1,82 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveUpdateFileMetadataOutputSchema } from '../output-schemas';
+
+export const driveUpdateFileMetadata = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_update_file_metadata',
+  displayName: 'Update File Metadata (Rename)',
+  description:
+    "Rename a Drive file/folder or update its description or starred flag (metadata only).",
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      "Renames a file/folder or updates its description or starred flag via a metadata-only PATCH. Use to rename or annotate a resource; this never changes the file's location — to re-parent use `drive_move_file`, and to replace the file's bytes use `drive_replace_file_content`. Safe to retry — re-applying the same values is a no-op.",
+    idempotent: true,
+  },
+  outputSchema: driveUpdateFileMetadataOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File or Folder ID',
+      description:
+        'The ID of the file or folder to update. Resolve it via `drive_search_files` or `drive_get_file`.',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'New Name',
+      description: 'A new name for the file or folder. Leave empty to keep the current name.',
+      required: false,
+    }),
+    description: Property.ShortText({
+      displayName: 'Description',
+      description: 'A new description for the file or folder. Leave empty to keep the current description.',
+      required: false,
+    }),
+    starred: Property.Checkbox({
+      displayName: 'Starred',
+      description: 'Whether to mark the file or folder as starred.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const { file_id, name, description, starred } = context.propsValue;
+
+    const requestBody: { name?: string; description?: string; starred?: boolean } =
+      {};
+    if (name !== undefined && name !== null && name !== '') {
+      requestBody.name = name;
+    }
+    if (description !== undefined && description !== null) {
+      requestBody.description = description;
+    }
+    if (starred !== undefined && starred !== null) {
+      requestBody.starred = starred;
+    }
+
+    const authClient = await createGoogleClient(context.auth);
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    try {
+      const response = await drive.files.update({
+        fileId: file_id,
+        supportsAllDrives: true,
+        requestBody,
+      });
+
+      return response.data;
+    } 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 updating file ${file_id}. You may lack edit permission on this resource.`
+        );
+      }
+      throw error;
+    }
+  },
+});

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

@@ -0,0 +1,100 @@
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { drive as googleDrive } from '@googleapis/drive';
+import { driveUpdatePermissionOutputSchema } from '../output-schemas';
+
+export const driveUpdatePermission = createAction({
+  auth: googleDriveAuth,
+  name: 'drive_update_permission',
+  displayName: 'Update Permission Role',
+  description: 'Change an existing collaborator\'s role on a Drive file or folder.',
+  audience: 'ai',
+  aiMetadata: {
+    description:
+      'Changes an existing collaborator\'s role in place (e.g. reader to writer), resolving the permission by their email internally. Use to upgrade or downgrade access without unsharing; to grant net-new access use drive_share_file. If the user has no existing grant it is a no-op (it never silently creates one). Safe to retry.',
+    idempotent: true,
+  },
+  outputSchema: driveUpdatePermissionOutputSchema,
+  props: {
+    file_id: Property.ShortText({
+      displayName: 'File or Folder ID',
+      description:
+        'The ID of the file or folder whose permission to update. 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 collaborator whose role to change. The existing permission is matched by this email; list current grants via drive_list_permissions.',
+      required: true,
+    }),
+    new_role: Property.StaticDropdown({
+      displayName: 'New Role',
+      description: 'The role to set for the user. See https://developers.google.com/drive/api/guides/ref-roles',
+      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, new_role } = context.propsValue;
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    try {
+      const response_permissions_list = await drive.permissions.list({
+        fileId: file_id,
+        fields: 'permissions(id,emailAddress,role)',
+        supportsAllDrives: true,
+      });
+
+      const permissions = response_permissions_list.data.permissions ?? [];
+
+      // Resolve the permission by email only (first match, deterministic).
+      // Never get-or-create: if no grant exists, report not-found, do not create one.
+      const match = permissions.find(
+        (permission) => permission.emailAddress === user_email
+      );
+
+      if (!match || !match.id) {
+        return {
+          updated: false,
+          message: `No existing permission found for ${user_email}. Use drive_share_file to grant new access.`,
+        };
+      }
+
+      const result = await drive.permissions.update({
+        fileId: file_id,
+        permissionId: match.id,
+        requestBody: { role: new_role },
+        supportsAllDrives: true,
+      });
+
+      return {
+        updated: true,
+        permission: result.data,
+      };
+    } 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 updating the role on file ${file_id}. You may lack permission to manage sharing on this resource.`
+        );
+      }
+      throw error;
+    }
+  },
+});