veryfront 0.0.48 → 0.0.50

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/drive/files/lib/token-store.ts

@@ -0,0 +1,113 @@
+/**
+ * OAuth Token Store
+ *
+ * Simple in-memory token store for development.
+ * Replace with a database or KV store for production.
+ */
+
+export interface OAuthToken {
+  accessToken: string;
+  refreshToken?: string;
+  expiresAt?: number;
+  tokenType?: string;
+  scope?: string;
+}
+
+export interface TokenStore {
+  getToken(userId: string, service: string): Promise<OAuthToken | null>;
+  setToken(userId: string, service: string, token: OAuthToken): Promise<void>;
+  revokeToken(userId: string, service: string): Promise<void>;
+  isConnected(userId: string, service: string): Promise<boolean>;
+}
+
+// In-memory storage for development
+// Use globalThis to share across esbuild bundles (each API route is bundled separately)
+const TOKENS_KEY = "__veryfront_oauth_tokens__";
+// deno-lint-ignore no-explicit-any
+const globalStore = globalThis as any;
+const tokens: Map<string, OAuthToken> = globalStore[TOKENS_KEY] ||= new Map<string, OAuthToken>();
+
+function getKey(userId: string, service: string): string {
+  return `${userId}:${service}`;
+}
+
+/**
+ * Simple in-memory token store
+ *
+ * NOTE: This is for development only. In production, use:
+ * - Database (Postgres, SQLite, etc.)
+ * - KV store (Cloudflare Workers KV, Vercel KV, etc.)
+ * - Encrypted file storage
+ */
+export const tokenStore: TokenStore = {
+  getToken(userId: string, service: string): Promise<OAuthToken | null> {
+    const key = getKey(userId, service);
+    return Promise.resolve(tokens.get(key) || null);
+  },
+
+  setToken(
+    userId: string,
+    service: string,
+    token: OAuthToken,
+  ): Promise<void> {
+    const key = getKey(userId, service);
+    tokens.set(key, token);
+    return Promise.resolve();
+  },
+
+  revokeToken(userId: string, service: string): Promise<void> {
+    const key = getKey(userId, service);
+    tokens.delete(key);
+    return Promise.resolve();
+  },
+
+  async isConnected(userId: string, service: string): Promise<boolean> {
+    const token = await this.getToken(userId, service);
+    if (!token) return false;
+    // Check if token is not expired (if no expiry, token doesn't expire)
+    return !token.expiresAt || token.expiresAt > Date.now();
+  },
+};
+
+/**
+ * Factory function to create a custom token store
+ */
+export function createTokenStore(options: {
+  get: (key: string) => Promise<string | null>;
+  set: (key: string, value: string) => Promise<void>;
+  delete: (key: string) => Promise<void>;
+}): TokenStore {
+  return {
+    async getToken(userId: string, service: string): Promise<OAuthToken | null> {
+      const key = getKey(userId, service);
+      const data = await options.get(key);
+      if (!data) return null;
+      try {
+        return JSON.parse(data) as OAuthToken;
+      } catch {
+        return null;
+      }
+    },
+
+    async setToken(
+      userId: string,
+      service: string,
+      token: OAuthToken,
+    ): Promise<void> {
+      const key = getKey(userId, service);
+      await options.set(key, JSON.stringify(token));
+    },
+
+    async revokeToken(userId: string, service: string): Promise<void> {
+      const key = getKey(userId, service);
+      await options.delete(key);
+    },
+
+    async isConnected(userId: string, service: string): Promise<boolean> {
+      const token = await this.getToken(userId, service);
+      if (!token) return false;
+      // Check if token is not expired (if no expiry, token doesn't expire)
+      return !token.expiresAt || token.expiresAt > Date.now();
+    },
+  };
+}

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;
+  },
+});