veryfront 0.0.49 → 0.0.51

package/dist/integrations/drive/files/lib/drive-client.ts

@@ -0,0 +1,359 @@
+/**
+ * Google Drive API Client
+ *
+ * Provides a type-safe interface to Google Drive API operations.
+ */
+
+import { tokenStore as _tokenStore } from "./token-store.ts";
+import { getValidToken } from "./oauth.ts";
+
+// Helper for Cross-Platform environment access
+function getEnv(key: string): string | undefined {
+  // @ts-ignore - Deno global
+  if (typeof Deno !== "undefined") {
+    // @ts-ignore - Deno global
+    return Deno.env.get(key);
+  } // @ts-ignore - process global
+  else if (typeof process !== "undefined" && process.env) {
+    // @ts-ignore - process global
+    return process.env[key];
+  }
+  return undefined;
+}
+
+const DRIVE_API_BASE = "https://www.googleapis.com/drive/v3";
+
+export interface DriveFile {
+  id: string;
+  name: string;
+  mimeType: string;
+  kind: string;
+  createdTime: string;
+  modifiedTime: string;
+  size?: string;
+  webViewLink?: string;
+  webContentLink?: string;
+  iconLink?: string;
+  thumbnailLink?: string;
+  parents?: string[];
+  starred?: boolean;
+  trashed?: boolean;
+  shared?: boolean;
+  owners?: Array<{
+    displayName: string;
+    emailAddress: string;
+    photoLink?: string;
+  }>;
+  lastModifyingUser?: {
+    displayName: string;
+    emailAddress: string;
+    photoLink?: string;
+  };
+  capabilities?: {
+    canEdit?: boolean;
+    canComment?: boolean;
+    canShare?: boolean;
+    canDelete?: boolean;
+    canDownload?: boolean;
+  };
+}
+
+export interface DriveFileList {
+  files: DriveFile[];
+  nextPageToken?: string;
+  incompleteSearch?: boolean;
+}
+
+export interface CreateFolderOptions {
+  name: string;
+  parentId?: string;
+  description?: string;
+}
+
+export interface UploadFileOptions {
+  name: string;
+  content: string;
+  mimeType: string;
+  parentId?: string;
+  description?: string;
+}
+
+export interface ListFilesOptions {
+  folderId?: string;
+  pageSize?: number;
+  pageToken?: string;
+  orderBy?: string;
+  query?: string;
+}
+
+export interface SearchFilesOptions {
+  query: string;
+  pageSize?: number;
+  pageToken?: string;
+  orderBy?: string;
+}
+
+/**
+ * Google Drive OAuth provider configuration
+ */
+export const driveOAuthProvider = {
+  name: "drive",
+  authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+  tokenUrl: "https://oauth2.googleapis.com/token",
+  clientId: getEnv("GOOGLE_CLIENT_ID") || "",
+  clientSecret: getEnv("GOOGLE_CLIENT_SECRET") || "",
+  scopes: [
+    "https://www.googleapis.com/auth/drive.readonly",
+    "https://www.googleapis.com/auth/drive.file",
+  ],
+  callbackPath: "/api/auth/drive/callback",
+};
+
+/**
+ * Create a Drive client for a specific user
+ */
+export function createDriveClient(userId: string) {
+  async function getAccessToken(): Promise<string> {
+    const token = await getValidToken(driveOAuthProvider, userId, "drive");
+    if (!token) {
+      throw new Error("Google Drive not connected. Please connect your Google account first.");
+    }
+    return token;
+  }
+
+  async function driveApiRequest<T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    const accessToken = await getAccessToken();
+
+    const response = await fetch(`${DRIVE_API_BASE}${endpoint}`, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Drive API error: ${response.status} - ${error}`);
+    }
+
+    return response.json();
+  }
+
+  return {
+    /**
+     * List files in a folder (or root if no folderId provided)
+     */
+    async listFiles(options: ListFilesOptions = {}): Promise<DriveFileList> {
+      const params = new URLSearchParams({
+        fields:
+          "nextPageToken,incompleteSearch,files(id,name,mimeType,kind,createdTime,modifiedTime,size,webViewLink,webContentLink,iconLink,thumbnailLink,parents,starred,trashed,shared,owners,lastModifyingUser,capabilities)",
+        pageSize: String(options.pageSize || 100),
+        orderBy: options.orderBy || "modifiedTime desc",
+      });
+
+      // Build query
+      let query = "trashed=false";
+
+      if (options.folderId) {
+        query += ` and '${options.folderId}' in parents`;
+      }
+
+      if (options.query) {
+        query += ` and ${options.query}`;
+      }
+
+      params.append("q", query);
+
+      if (options.pageToken) {
+        params.append("pageToken", options.pageToken);
+      }
+
+      return driveApiRequest<DriveFileList>(`/files?${params.toString()}`);
+    },
+
+    /**
+     * Get metadata about a specific file
+     */
+    async getFile(fileId: string): Promise<DriveFile> {
+      const params = new URLSearchParams({
+        fields:
+          "id,name,mimeType,kind,createdTime,modifiedTime,size,webViewLink,webContentLink,iconLink,thumbnailLink,parents,starred,trashed,shared,owners,lastModifyingUser,capabilities",
+      });
+
+      return driveApiRequest<DriveFile>(`/files/${fileId}?${params.toString()}`);
+    },
+
+    /**
+     * Search for files using Drive query syntax
+     */
+    async searchFiles(options: SearchFilesOptions): Promise<DriveFileList> {
+      const params = new URLSearchParams({
+        fields:
+          "nextPageToken,incompleteSearch,files(id,name,mimeType,kind,createdTime,modifiedTime,size,webViewLink,webContentLink,iconLink,thumbnailLink,parents,starred,trashed)",
+        pageSize: String(options.pageSize || 100),
+        q: `${options.query} and trashed=false`,
+        orderBy: options.orderBy || "modifiedTime desc",
+      });
+
+      if (options.pageToken) {
+        params.append("pageToken", options.pageToken);
+      }
+
+      return driveApiRequest<DriveFileList>(`/files?${params.toString()}`);
+    },
+
+    /**
+     * Create a new folder
+     */
+    async createFolder(options: CreateFolderOptions): Promise<DriveFile> {
+      const metadata: Record<string, unknown> = {
+        name: options.name,
+        mimeType: "application/vnd.google-apps.folder",
+      };
+
+      if (options.parentId) {
+        metadata.parents = [options.parentId];
+      }
+
+      if (options.description) {
+        metadata.description = options.description;
+      }
+
+      return driveApiRequest<DriveFile>("/files", {
+        method: "POST",
+        body: JSON.stringify(metadata),
+      });
+    },
+
+    /**
+     * Upload a text file to Drive
+     */
+    async uploadFile(options: UploadFileOptions): Promise<DriveFile> {
+      const accessToken = await getAccessToken();
+
+      // Create multipart upload
+      const boundary = "-------314159265358979323846";
+      const delimiter = `\r\n--${boundary}\r\n`;
+      const closeDelimiter = `\r\n--${boundary}--`;
+
+      const metadata: Record<string, unknown> = {
+        name: options.name,
+        mimeType: options.mimeType,
+      };
+
+      if (options.parentId) {
+        metadata.parents = [options.parentId];
+      }
+
+      if (options.description) {
+        metadata.description = options.description;
+      }
+
+      const multipartRequestBody =
+        delimiter +
+        "Content-Type: application/json\r\n\r\n" +
+        JSON.stringify(metadata) +
+        delimiter +
+        `Content-Type: ${options.mimeType}\r\n\r\n` +
+        options.content +
+        closeDelimiter;
+
+      const response = await fetch(
+        "https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&fields=id,name,mimeType,kind,createdTime,modifiedTime,size,webViewLink,webContentLink",
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            "Content-Type": `multipart/related; boundary=${boundary}`,
+          },
+          body: multipartRequestBody,
+        },
+      );
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Drive upload error: ${response.status} - ${error}`);
+      }
+
+      return response.json();
+    },
+
+    /**
+     * Download file content as text
+     */
+    async downloadFile(fileId: string): Promise<string> {
+      const accessToken = await getAccessToken();
+
+      const response = await fetch(
+        `${DRIVE_API_BASE}/files/${fileId}?alt=media`,
+        {
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+          },
+        },
+      );
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Drive download error: ${response.status} - ${error}`);
+      }
+
+      return response.text();
+    },
+
+    /**
+     * Delete a file or folder (move to trash)
+     */
+    async deleteFile(fileId: string): Promise<void> {
+      await driveApiRequest(`/files/${fileId}`, {
+        method: "DELETE",
+      });
+    },
+
+    /**
+     * Copy a file
+     */
+    async copyFile(
+      fileId: string,
+      name: string,
+      parentId?: string,
+    ): Promise<DriveFile> {
+      const metadata: Record<string, unknown> = {
+        name,
+      };
+
+      if (parentId) {
+        metadata.parents = [parentId];
+      }
+
+      return driveApiRequest<DriveFile>(`/files/${fileId}/copy`, {
+        method: "POST",
+        body: JSON.stringify(metadata),
+      });
+    },
+
+    /**
+     * Update file metadata
+     */
+    async updateFile(
+      fileId: string,
+      updates: {
+        name?: string;
+        description?: string;
+        starred?: boolean;
+      },
+    ): Promise<DriveFile> {
+      return driveApiRequest<DriveFile>(`/files/${fileId}`, {
+        method: "PATCH",
+        body: JSON.stringify(updates),
+      });
+    },
+  };
+}
+
+export type DriveClient = ReturnType<typeof createDriveClient>;

package/dist/integrations/dropbox/connector.json

@@ -0,0 +1,107 @@
+{
+  "name": "dropbox",
+  "displayName": "Dropbox",
+  "icon": "dropbox.svg",
+  "description": "Access, search, and manage files in your Dropbox storage",
+  "auth": {
+    "type": "oauth2",
+    "provider": "dropbox",
+    "authorizationUrl": "https://www.dropbox.com/oauth2/authorize",
+    "tokenUrl": "https://api.dropboxapi.com/oauth2/token",
+    "scopes": [
+      "files.content.read",
+      "files.content.write",
+      "files.metadata.read",
+      "files.metadata.write",
+      "account_info.read"
+    ],
+    "callbackPath": "/api/auth/dropbox/callback",
+    "tokenAuthMethod": "request_body",
+    "supportsRefreshToken": true,
+    "requiredApis": [
+      {
+        "name": "Dropbox App",
+        "enableUrl": "https://www.dropbox.com/developers/apps"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "DROPBOX_APP_KEY",
+      "description": "Dropbox App Key (Client ID)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://www.dropbox.com/developers/apps"
+    },
+    {
+      "name": "DROPBOX_APP_SECRET",
+      "description": "Dropbox App Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://www.dropbox.com/developers/apps"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-files",
+      "name": "List Files",
+      "description": "List files and folders in a Dropbox folder",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-file",
+      "name": "Get File",
+      "description": "Get file metadata and optionally download file content",
+      "requiresWrite": false
+    },
+    {
+      "id": "upload-file",
+      "name": "Upload File",
+      "description": "Upload or update a file in Dropbox",
+      "requiresWrite": true
+    },
+    {
+      "id": "search-files",
+      "name": "Search Files",
+      "description": "Search for files and folders by name or content",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-account",
+      "name": "Get Account Info",
+      "description": "Get current user account information and storage usage",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "find-documents",
+      "title": "Find my documents",
+      "prompt": "Search my Dropbox for specific documents or files by name or content.",
+      "category": "productivity",
+      "icon": "search"
+    },
+    {
+      "id": "organize-files",
+      "title": "Organize files",
+      "prompt": "Help me organize and manage files in my Dropbox, including moving, copying, or cleaning up duplicates.",
+      "category": "productivity",
+      "icon": "folder"
+    },
+    {
+      "id": "backup-file",
+      "title": "Backup a file",
+      "prompt": "Upload and backup a file to my Dropbox storage.",
+      "category": "productivity",
+      "icon": "upload"
+    },
+    {
+      "id": "check-storage",
+      "title": "Check storage",
+      "prompt": "Check my Dropbox storage usage and available space.",
+      "category": "productivity",
+      "icon": "database"
+    }
+  ],
+  "suggestedWith": ["notion", "gmail", "drive"]
+}

package/dist/integrations/dropbox/files/_env.example

@@ -0,0 +1,24 @@
+# Dropbox Integration Environment Variables
+
+# Dropbox App Key (Client ID)
+# Get this from https://www.dropbox.com/developers/apps
+DROPBOX_APP_KEY=your_app_key_here
+
+# Dropbox App Secret
+# Get this from https://www.dropbox.com/developers/apps
+DROPBOX_APP_SECRET=your_app_secret_here
+
+# Setup Instructions:
+# 1. Go to https://www.dropbox.com/developers/apps
+# 2. Create a new app or select an existing one
+# 3. Choose "Scoped access" as the API type
+# 4. Select "Full Dropbox" or "App folder" access
+# 5. Copy the App Key and App Secret
+# 6. Add the OAuth2 redirect URI: http://localhost:3000/api/auth/dropbox/callback
+# 7. Enable the following permissions in the Permissions tab:
+#    - files.content.read
+#    - files.content.write
+#    - files.metadata.read
+#    - files.metadata.write
+#    - account_info.read
+# 8. Submit the app for production use if needed

package/dist/integrations/dropbox/files/ai/tools/get-account.ts

@@ -0,0 +1,58 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatFileSize, getCurrentAccount, getSpaceUsage } from "../../lib/dropbox-client.ts";
+
+export default tool({
+  id: "get-account",
+  description: "Get current Dropbox account information including user details and storage usage.",
+  inputSchema: z.object({
+    includeSpaceUsage: z.boolean().default(true).describe(
+      "Whether to include storage usage information",
+    ),
+  }),
+  async execute({ includeSpaceUsage }) {
+    const account = await getCurrentAccount();
+
+    const result: Record<string, unknown> = {
+      accountId: account.account_id,
+      name: {
+        displayName: account.name.display_name,
+        givenName: account.name.given_name,
+        surname: account.name.surname,
+        familiarName: account.name.familiar_name,
+      },
+      email: account.email,
+      emailVerified: account.email_verified,
+      accountType: account.account_type[".tag"],
+      country: account.country,
+      locale: account.locale,
+      disabled: account.disabled,
+    };
+
+    if (includeSpaceUsage) {
+      try {
+        const spaceUsage = await getSpaceUsage();
+
+        const used = spaceUsage.used;
+        const allocated = spaceUsage.allocation.allocated;
+
+        result.storage = {
+          used,
+          usedFormatted: formatFileSize(used),
+          allocated: allocated || 0,
+          allocatedFormatted: allocated ? formatFileSize(allocated) : "N/A",
+          allocationType: spaceUsage.allocation[".tag"],
+          percentUsed: allocated ? Math.round((used / allocated) * 100) : 0,
+          available: allocated ? allocated - used : 0,
+          availableFormatted: allocated ? formatFileSize(allocated - used) : "N/A",
+        };
+      } catch (error) {
+        result.storageError = error instanceof Error
+          ? error.message
+          : "Failed to get storage usage";
+      }
+    }
+
+    return result;
+  },
+});

package/dist/integrations/dropbox/files/ai/tools/get-file.ts

@@ -0,0 +1,61 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { downloadFile, formatFileSize, getMetadata, isFile } from "../../lib/dropbox-client.ts";
+
+export default tool({
+  id: "get-file",
+  description:
+    "Get file metadata and optionally download file content from Dropbox. Use this to read file information or retrieve file contents.",
+  inputSchema: z.object({
+    path: z.string().describe('Path to the file in Dropbox (e.g., "/Documents/file.txt")'),
+    includeContent: z.boolean().default(false).describe(
+      "Whether to download and return the file content (only works for text files and small files)",
+    ),
+  }),
+  async execute({ path, includeContent }) {
+    // Get metadata first
+    const metadata = await getMetadata(path);
+
+    if (!isFile(metadata)) {
+      throw new Error(`Path "${path}" is not a file, it's a ${metadata[".tag"]}`);
+    }
+
+    const result: Record<string, unknown> = {
+      name: metadata.name,
+      path: metadata.path_display || metadata.path_lower || "",
+      id: metadata.id,
+      size: metadata.size,
+      sizeFormatted: formatFileSize(metadata.size),
+      modified: metadata.server_modified,
+      clientModified: metadata.client_modified,
+      isDownloadable: metadata.is_downloadable,
+      rev: metadata.rev,
+    };
+
+    // Download content if requested
+    if (includeContent) {
+      if (!metadata.is_downloadable) {
+        throw new Error(`File "${path}" is not downloadable`);
+      }
+
+      // Only download small files (< 1MB) to avoid memory issues
+      if (metadata.size > 1024 * 1024) {
+        throw new Error(
+          `File is too large to download content (${
+            formatFileSize(metadata.size)
+          }). Maximum size is 1MB. Use includeContent: false to get metadata only.`,
+        );
+      }
+
+      try {
+        const { content } = await downloadFile(path);
+        result.content = content;
+        result.contentLength = content.length;
+      } catch (error) {
+        result.contentError = error instanceof Error ? error.message : "Failed to download content";
+      }
+    }
+
+    return result;
+  },
+});

package/dist/integrations/dropbox/files/ai/tools/list-files.ts

@@ -0,0 +1,56 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatFileSize, isFile, isFolder, listFolder } from "../../lib/dropbox-client.ts";
+
+export default tool({
+  id: "list-files",
+  description:
+    "List files and folders in a Dropbox folder. Returns file/folder names, types, sizes, and modification dates.",
+  inputSchema: z.object({
+    path: z.string().default("").describe(
+      'Path to the folder to list (empty string for root, or "/FolderName" for specific folder)',
+    ),
+    recursive: z.boolean().default(false).describe(
+      "Whether to list files recursively in subfolders",
+    ),
+    limit: z.number().min(1).max(500).default(100).describe("Maximum number of items to return"),
+  }),
+  async execute({ path, recursive, limit }) {
+    const result = await listFolder(path, {
+      recursive,
+      limit,
+    });
+
+    const items = result.entries.map((entry) => {
+      const baseInfo = {
+        name: entry.name,
+        path: entry.path_display || entry.path_lower || "",
+        id: entry.id,
+        type: entry[".tag"],
+      };
+
+      if (isFile(entry)) {
+        return {
+          ...baseInfo,
+          size: entry.size,
+          sizeFormatted: formatFileSize(entry.size),
+          modified: entry.server_modified,
+          clientModified: entry.client_modified,
+          isDownloadable: entry.is_downloadable,
+          rev: entry.rev,
+        };
+      } else if (isFolder(entry)) {
+        return baseInfo;
+      }
+
+      return baseInfo;
+    });
+
+    return {
+      items,
+      count: items.length,
+      hasMore: result.has_more,
+      cursor: result.cursor,
+    };
+  },
+});