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

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

@@ -0,0 +1,48 @@
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { common } from '../common';
+import { drive as googleDrive } from '@googleapis/drive';
+import { googleDriveMoveFileActionOutputSchema } from '../output-schemas';
+
+export const moveFileAction = createAction({
+  auth: googleDriveAuth,
+  name: 'google-drive-move-file',
+  displayName: 'Move File',
+  description: 'Moves a file from one folder to another.',
+  audience: 'human',
+  aiMetadata: { description: 'Relocates a Drive file to a target folder, detaching it from its current parents and attaching it to the new one. Use to reorganize a file once you know its ID and the destination folder ID. Idempotent: repeating with the same destination leaves the file in the same folder.', idempotent: true },
+  props: {
+    fileId: Property.ShortText({
+      displayName: 'File ID',
+      description: 'You can use **Search Folder/File** action to retrieve ID.',
+      required: true,
+    }),
+    include_team_drives: common.properties.include_team_drives,
+    folderId: common.properties.parentFolder,
+  },
+  outputSchema: googleDriveMoveFileActionOutputSchema,
+  async run(context) {
+    const fileId = context.propsValue.fileId;
+    const folderId = context.propsValue.folderId;
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    const file = await drive.files.get({
+      fileId,
+      supportsAllDrives: context.propsValue.include_team_drives,
+      fields: 'id,parents',
+    });
+
+    const response = await drive.files.update({
+      fileId: fileId,
+      fields: '*',
+      removeParents: file.data.parents?.join(','),
+      addParents: folderId,
+      supportsAllDrives: context.propsValue.include_team_drives,
+    });
+
+    return response.data;
+  },
+});

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

@@ -0,0 +1,28 @@
+import { googleDriveAuth } from '../auth';
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { downloadFileFromDrive } from '../common/get-file-content';
+import { readFileActionOutputSchema } from '../output-schemas';
+
+export const readFile = createAction({
+  auth: googleDriveAuth,
+  name: 'read-file',
+  displayName: 'Read File Content',
+  description: 'Read a selected file from google drive file',
+  audience: 'human',
+  aiMetadata: { description: 'Downloads the content of a Drive file by its file ID and returns it as a usable file reference. Use to retrieve a file an agent already knows the ID of (e.g. from a trigger or search). Read-only and idempotent. Requires the exact file ID, not a name.', idempotent: true },
+  props: {
+    fileId: Property.ShortText({
+      displayName: 'File ID',
+      description: 'File ID coming from | New File -> id |',
+      required: true,
+    }),
+    fileName: Property.ShortText({
+      displayName: 'Destination File name',
+      required: false,
+    }),
+  },
+  outputSchema: readFileActionOutputSchema,
+  run: async ({ auth, propsValue, files }) => {
+    return downloadFileFromDrive(auth, files, propsValue.fileId, propsValue.fileName)
+  },
+});

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

@@ -0,0 +1,76 @@
+/* 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 { common } from '../common';
+import { saveFileAsPdfActionOutputSchema } from '../output-schemas';
+
+export const saveFileAsPdf = createAction({
+  displayName: 'Save Document as PDF',
+  auth: googleDriveAuth,
+  name: 'save_file_as_pdf',
+  description: 'Save a document as PDF in a Google Drive folder',
+  audience: 'human',
+  aiMetadata: { description: 'Exports a 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. Requires the source document ID and destination folder ID. Not idempotent: each call creates a new PDF file.', idempotent: false },
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to export',
+      required: true,
+    }),
+    folderId: Property.ShortText({
+      displayName: 'Folder ID',
+      description: 'The ID of the folder where the file will be exported',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'Name',
+      description: 'The name of the new file (do not include the extension)',
+      required: true,
+    }),
+    include_team_drives: common.properties.include_team_drives,
+  },
+  outputSchema: saveFileAsPdfActionOutputSchema,
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const documentId = context.propsValue.documentId;
+    const folderId = context.propsValue.folderId;
+    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: context.propsValue.include_team_drives,
+    });
+
+    return file.data;
+  },
+});

package/src/lib/action/search-folder-or-file.action.ts

@@ -0,0 +1,112 @@
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { drive as googleDrive } from '@googleapis/drive';
+import { common } from '../common';
+import { searchFolderActionOutputSchema } from '../output-schemas';
+
+export const googleDriveSearchFolder = createAction({
+  auth: googleDriveAuth,
+  name: 'search-folder',
+  displayName: 'Search',
+  description: 'Search a Google Drive folder for files/sub-folders',
+  audience: 'human',
+  aiMetadata: { description: 'Searches Google Drive for files or folders matching a name, full-text, or MIME-type query, optionally scoped to a parent folder and filtered to files or folders only. Use to resolve a file/folder ID from a human-readable name before acting on it. Read-only and idempotent.', idempotent: true },
+  props: {
+    queryTerm: 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',
+    }),
+    query: 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',
+    }),
+    parentFolder: common.properties.parentFolder,
+    include_team_drives: common.properties.include_team_drives,
+  },
+  outputSchema: searchFolderActionOutputSchema,
+  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.queryTerm ?? 'name';
+    let finalQuery = `${queryTerm} ${operator} '${context.propsValue.query}'`;
+    if (context.propsValue.parentFolder) {
+      finalQuery = `${finalQuery} and '${context.propsValue.parentFolder}' 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/send-to-trash.ts

@@ -0,0 +1,38 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { common } from '../common';
+import { drive as googleDrive } from '@googleapis/drive';
+import { trashGdriveFileActionOutputSchema } from '../output-schemas';
+
+export const googleDriveTrashFile = createAction({
+  auth: googleDriveAuth,
+  name: 'trash_gdrive_file',
+  description: 'Move a file to the trash in your Google Drive',
+  audience: 'human',
+  aiMetadata: { description: 'Moves a Drive file to the trash by its ID, a reversible deletion that can be restored from Drive. Use for safe removal instead of permanent deletion. Requires the file ID. Idempotent: re-trashing an already-trashed file leaves it in the same state.', idempotent: true },
+  displayName: 'Trash file',
+  props: {
+    fileId: Property.ShortText({
+      displayName: 'File ID',
+      description: 'The ID of the file to trash',
+      required: true,
+    }),
+    include_team_drives: common.properties.include_team_drives,
+  },
+  outputSchema: trashGdriveFileActionOutputSchema,
+  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.fileId,
+      supportsAllDrives: context.propsValue.include_team_drives,
+      requestBody: body_value,
+    });
+
+    return response.data;
+  },
+});

package/src/lib/action/set-public-access.ts

@@ -0,0 +1,68 @@
+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 { setPublicAccessActionOutputSchema } from '../output-schemas';
+
+export const setPublicAccess = createAction({
+  auth: googleDriveAuth,
+  name: 'set_public_access',
+  description: 'Set public access for a file or folder',
+  audience: 'human',
+  aiMetadata: { description: 'Makes a Drive file or folder accessible to anyone with the link at the chosen role (reader, commenter, or writer) and returns its shareable view/download URL. Use to publish a resource publicly. Requires the file/folder ID. Not idempotent: each call adds a new anyone-with-link permission.', idempotent: false },
+  displayName: 'Set public access',
+  props: {
+    fileId: Property.ShortText({
+      displayName: 'File or Folder ID',
+      description: 'The ID of the file or folder to update permissions for',
+      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,
+    }),
+  },
+  outputSchema: setPublicAccessActionOutputSchema,
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const fileId = context.propsValue.fileId;
+    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,
+    });
+
+    const file = await drive.files.get({
+      fileId: fileId,
+      fields: 'name,mimeType,webContentLink,webViewLink',
+    });
+
+    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/upload-file.ts

@@ -0,0 +1,55 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { Readable } from 'stream';
+import mime from 'mime-types';
+import { drive as googleDrive } from '@googleapis/drive';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { common } from '../common';
+import { uploadGdriveFileActionOutputSchema } from '../output-schemas';
+
+export const googleDriveUploadFile = createAction({
+  auth: googleDriveAuth,
+  name: 'upload_gdrive_file',
+  description: 'Upload a file in your Google Drive',
+  audience: 'human',
+  aiMetadata: { description: 'Uploads a binary file (from a URL or base64 input) into Google Drive, optionally inside a parent folder. Use to store an existing file or attachment in Drive; the MIME type is inferred from the file extension. Not idempotent: each call creates a new file.', idempotent: false },
+  displayName: 'Upload file',
+  props: {
+    fileName: 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,
+    }),
+    parentFolder: common.properties.parentFolder,
+    include_team_drives: common.properties.include_team_drives,
+  },
+  outputSchema: uploadGdriveFileActionOutputSchema,
+  async run(context) {
+    const fileData = context.propsValue.file;
+    const mimeType = mime.lookup(fileData.extension ?? '') || 'application/octet-stream';
+
+    const authClient = await createGoogleClient(context.auth);
+    const drive = googleDrive({ version: 'v3', auth: authClient });
+
+    const response = await drive.files.create({
+      requestBody: {
+        name: context.propsValue.fileName,
+        ...(context.propsValue.parentFolder
+          ? { parents: [context.propsValue.parentFolder] }
+          : {}),
+      },
+      media: {
+        mimeType,
+        body: Readable.from(Buffer.from(fileData.base64, 'base64')),
+      },
+      supportsAllDrives: context.propsValue.include_team_drives ?? false,
+      fields: 'id, name, mimeType, kind',
+    });
+
+    return response.data;
+  },
+});

package/src/lib/auth.ts

@@ -0,0 +1,79 @@
+import { AppConnectionValueForAuthProperty, PieceAuth, Property } from '@agnocon/pieces-framework';
+import { AppConnectionType } from '@agnocon/pieces-framework';
+import { JWT, OAuth2Client } from 'google-auth-library';
+
+export const googleDriveScopes = ['https://www.googleapis.com/auth/drive', 'email'];
+
+export const googleDriveAuth = [PieceAuth.OAuth2({
+  description: '',
+  authUrl: 'https://accounts.google.com/o/oauth2/auth',
+  tokenUrl: 'https://oauth2.googleapis.com/token',
+  required: true,
+  scope: googleDriveScopes,
+}), PieceAuth.CustomAuth({
+  displayName: 'Service Account (Advanced)',
+  description: 'Authenticate via service account from https://console.cloud.google.com/ > IAM & Admin > Service Accounts > Create Service Account > Keys > Add key.  <br> <br> You can optionally use domain-wide delegation (https://support.google.com/a/answer/162106?hl=en#zippy=%2Cset-up-domain-wide-delegation-for-a-client) to access files without adding the service account to each one. <br> <br> **Note:** Without a user email, the service account only has access to files/folders you explicitly share with it.',
+  required: true,
+  props: {
+    serviceAccount: Property.LongText({
+      displayName: 'Service Account JSON Key',
+      required: true,
+    }),
+    userEmail: Property.ShortText({
+      displayName: 'User Email',
+      required: false,
+      description: 'Email address of the user to impersonate for domain-wide delegation.',
+    }),
+  },
+  validate: async ({ auth }) => {
+    try {
+      await getAccessToken({
+        type: AppConnectionType.CUSTOM_AUTH,
+        props: { ...auth },
+      });
+    } catch (e) {
+      return {
+        valid: false,
+        error: (e as Error).message,
+      };
+    }
+    return {
+      valid: true,
+    };
+  },
+})];
+
+export type GoogleDriveAuthValue = AppConnectionValueForAuthProperty<typeof googleDriveAuth>;
+
+export async function createGoogleClient(auth: GoogleDriveAuthValue): Promise<OAuth2Client> {
+  if (auth.type === AppConnectionType.CUSTOM_AUTH) {
+    let serviceAccount;
+    try {
+      serviceAccount = JSON.parse(auth.props.serviceAccount);
+    } catch {
+      throw new Error('Invalid Service Account JSON Key. Please provide a valid JSON string.');
+    }
+    return new JWT({
+      email: serviceAccount.client_email,
+      key: serviceAccount.private_key,
+      scopes: googleDriveScopes,
+      subject: auth.props.userEmail,
+    });
+  }
+  const authClient = new OAuth2Client();
+  authClient.setCredentials(auth);
+  return authClient;
+}
+
+export const getAccessToken = async (auth: GoogleDriveAuthValue): Promise<string> => {
+  if (auth.type === AppConnectionType.CUSTOM_AUTH) {
+    const googleClient = await createGoogleClient(auth);
+    const response = await googleClient.getAccessToken();
+    if (response.token) {
+      return response.token;
+    } else {
+      throw new Error('Could not retrieve access token from service account json');
+    }
+  }
+  return auth.access_token;
+};

package/src/lib/common/get-file-content.ts

@@ -0,0 +1,109 @@
+import {
+  FilesService,
+} from '@agnocon/pieces-framework';
+import { extension } from 'mime-types';
+import { GoogleDriveAuthValue, getAccessToken } from '../auth';
+
+async function getMimeType(
+  auth: GoogleDriveAuthValue,
+  fileId: string
+): Promise<string> {
+  const accessToken = await getAccessToken(auth);
+  const mimeType = (
+    await fetch(
+      `https://www.googleapis.com/drive/v3/files/${fileId}?fields=mimeType&supportsAllDrives=true`,
+      {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+        },
+      }
+    ).then((res) => res.json())
+  )['mimeType'] as string;
+  return mimeType;
+}
+
+const googledlCall = async (
+  url: string,
+  auth: GoogleDriveAuthValue,
+  fileId: string,
+  files: FilesService,
+  fileName: string | undefined
+) => {
+  const mimeType = await getMimeType(auth, fileId);
+  const accessToken = await getAccessToken(auth);
+
+  const download = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+  })
+    .then((response) =>
+      response.ok ? response.blob() : Promise.reject(response)
+    )
+    .catch((error) =>
+      Promise.reject(
+        new Error(
+          `Error when download file:\n\tDownload file response: ${
+            (error as Error).message ?? error
+          }`
+        )
+      )
+    );
+
+  const extensionResult = extension(mimeType);
+  const fileExtension = extensionResult ? '.' + extensionResult : '';
+  const srcFileName = fileName ?? fileId + fileExtension;
+
+  return files.write({
+    fileName: srcFileName,
+    data: Buffer.from(await download.arrayBuffer()),
+  });
+};
+
+export async function downloadFileFromDrive(
+  auth: GoogleDriveAuthValue,
+  files: FilesService,
+  fileId: string,
+  fileName: string | undefined
+): Promise<string> {
+  let mimeType = await getMimeType(auth, fileId);
+
+  // the google drive API doesn't allowed downloading google documents but we can export them to office formats
+  if (
+    [
+      'application/vnd.google-apps.document',
+      'application/vnd.google-apps.spreadsheet',
+      'application/vnd.google-apps.presentation',
+    ].includes(mimeType)
+  ) {
+    switch (mimeType) {
+      case 'application/vnd.google-apps.document':
+        mimeType =
+          'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+        break;
+      case 'application/vnd.google-apps.spreadsheet':
+        mimeType =
+          'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+        break;
+      case 'application/vnd.google-apps.presentation':
+        mimeType =
+          'application/vnd.openxmlformats-officedocument.presentationml.presentation';
+        break;
+    }
+    return await googledlCall(
+      `https://www.googleapis.com/drive/v3/files/${fileId}/export?mimeType=${mimeType}&supportsAllDrives=true`,
+      auth,
+      fileId,
+      files,
+      fileName
+    );
+  } else {
+    return await googledlCall(
+      `https://www.googleapis.com/drive/v3/files/${fileId}?alt=media&supportsAllDrives=true`,
+      auth,
+      fileId,
+      files,
+      fileName
+    );
+  }
+}