veryfront 0.0.48 → 0.0.50

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

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

@@ -0,0 +1,70 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatFileSize, isFile, searchFiles } from "../../lib/dropbox-client.ts";
+
+export default tool({
+  id: "search-files",
+  description:
+    "Search for files and folders in Dropbox by name or content. Returns matching items with their paths and metadata.",
+  inputSchema: z.object({
+    query: z.string().describe("Search query to find files or folders"),
+    path: z.string().optional().describe("Optional path to limit search to a specific folder"),
+    maxResults: z.number().min(1).max(100).default(20).describe(
+      "Maximum number of results to return",
+    ),
+    fileCategories: z.array(
+      z.enum([
+        "image",
+        "document",
+        "pdf",
+        "spreadsheet",
+        "presentation",
+        "audio",
+        "video",
+        "folder",
+        "paper",
+        "others",
+      ]),
+    ).optional().describe("Filter by file categories"),
+  }),
+  async execute({ query, path, maxResults, fileCategories }) {
+    const result = await searchFiles(query, {
+      path,
+      maxResults,
+      fileCategories,
+    });
+
+    const matches = result.matches.map((match) => {
+      const metadata = match.metadata.metadata;
+      const matchType = match.match_type[".tag"];
+
+      const baseInfo = {
+        name: metadata.name,
+        path: metadata.path_display || metadata.path_lower || "",
+        id: metadata.id,
+        type: metadata[".tag"],
+        matchType,
+      };
+
+      if (isFile(metadata)) {
+        return {
+          ...baseInfo,
+          size: metadata.size,
+          sizeFormatted: formatFileSize(metadata.size),
+          modified: metadata.server_modified,
+          clientModified: metadata.client_modified,
+          isDownloadable: metadata.is_downloadable,
+        };
+      }
+
+      return baseInfo;
+    });
+
+    return {
+      matches,
+      count: matches.length,
+      hasMore: result.has_more,
+      query,
+    };
+  },
+});

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

@@ -0,0 +1,48 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatFileSize, uploadFile } from "../../lib/dropbox-client.ts";
+
+export default tool({
+  id: "upload-file",
+  description:
+    "Upload or update a file in Dropbox. Can create new files or overwrite existing ones.",
+  inputSchema: z.object({
+    path: z.string().describe(
+      'Full path where the file should be saved in Dropbox (e.g., "/Documents/notes.txt")',
+    ),
+    content: z.string().describe("The content to write to the file"),
+    mode: z.enum(["add", "overwrite", "update"]).default("add").describe(
+      'Upload mode: "add" (fail if exists), "overwrite" (replace if exists), "update" (update specific revision)',
+    ),
+    autorename: z.boolean().default(false).describe(
+      "If true and file exists, automatically rename to avoid conflicts",
+    ),
+  }),
+  async execute({ path, content, mode, autorename }) {
+    // Validate path
+    if (!path.startsWith("/")) {
+      throw new Error('Path must start with "/" (e.g., "/Documents/file.txt")');
+    }
+
+    // Upload the file
+    const result = await uploadFile(path, content, {
+      mode,
+      autorename,
+      mute: false,
+    });
+
+    return {
+      success: true,
+      name: result.name,
+      path: result.path_display || result.path_lower || "",
+      id: result.id,
+      size: result.size,
+      sizeFormatted: formatFileSize(result.size),
+      modified: result.server_modified,
+      rev: result.rev,
+      message: mode === "add"
+        ? `File created successfully at ${result.path_display}`
+        : `File updated successfully at ${result.path_display}`,
+    };
+  },
+});

package/dist/integrations/dropbox/files/app/api/auth/dropbox/callback/route.ts

@@ -0,0 +1,11 @@
+/**
+ * Dropbox OAuth Callback
+ */
+
+import { createOAuthCallbackHandler, dropboxConfig, memoryTokenStore } from "veryfront/oauth";
+
+export const GET = createOAuthCallbackHandler(dropboxConfig, {
+  tokenStore: memoryTokenStore,
+  onSuccess: () => "/",
+  onError: () => "/",
+});

package/dist/integrations/dropbox/files/app/api/auth/dropbox/route.ts

@@ -0,0 +1,9 @@
+/**
+ * Dropbox OAuth Initiation
+ */
+
+import { createOAuthInitHandler, dropboxConfig, memoryTokenStore } from "veryfront/oauth";
+
+export const GET = createOAuthInitHandler(dropboxConfig, {
+  tokenStore: memoryTokenStore,
+});

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

@@ -0,0 +1,397 @@
+import { getAccessToken } from "./token-store.ts";
+
+const DROPBOX_API_URL = "https://api.dropboxapi.com/2";
+const DROPBOX_CONTENT_URL = "https://content.dropboxapi.com/2";
+
+// Dropbox API Types
+export interface DropboxMetadata {
+  ".tag": "file" | "folder" | "deleted";
+  name: string;
+  path_lower?: string;
+  path_display?: string;
+  id: string;
+}
+
+export interface DropboxFileMetadata extends DropboxMetadata {
+  ".tag": "file";
+  client_modified: string;
+  server_modified: string;
+  rev: string;
+  size: number;
+  is_downloadable: boolean;
+  content_hash?: string;
+}
+
+export interface DropboxFolderMetadata extends DropboxMetadata {
+  ".tag": "folder";
+}
+
+export interface ListFolderResult {
+  entries: Array<DropboxFileMetadata | DropboxFolderMetadata>;
+  cursor: string;
+  has_more: boolean;
+}
+
+export interface SearchResult {
+  matches: Array<{
+    match_type: {
+      ".tag": "filename" | "content" | "both";
+    };
+    metadata: {
+      ".tag": "metadata";
+      metadata: DropboxFileMetadata | DropboxFolderMetadata;
+    };
+  }>;
+  has_more: boolean;
+  cursor?: string;
+}
+
+export interface AccountInfo {
+  account_id: string;
+  name: {
+    given_name: string;
+    surname: string;
+    familiar_name: string;
+    display_name: string;
+  };
+  email: string;
+  email_verified: boolean;
+  disabled: boolean;
+  country: string;
+  locale: string;
+  account_type: {
+    ".tag": "basic" | "pro" | "business";
+  };
+}
+
+export interface SpaceUsage {
+  used: number;
+  allocation: {
+    ".tag": "individual" | "team";
+    allocated?: number;
+  };
+}
+
+export interface SharedLinkMetadata {
+  url: string;
+  id: string;
+  name: string;
+  path_lower?: string;
+  link_permissions: {
+    can_revoke: boolean;
+    resolved_visibility?: {
+      ".tag": "public" | "team_only" | "password";
+    };
+  };
+}
+
+// Helper function for Dropbox RPC API calls
+async function dropboxRPC<T>(
+  endpoint: string,
+  body: Record<string, unknown> = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Dropbox. Please connect your account.");
+  }
+
+  const response = await fetch(`${DROPBOX_API_URL}${endpoint}`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Dropbox API error: ${response.status} ${error.error_summary || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+// Helper function for Dropbox Content API calls
+async function dropboxContent<T>(
+  endpoint: string,
+  args: Record<string, unknown>,
+  content?: string | Uint8Array,
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Dropbox. Please connect your account.");
+  }
+
+  const headers: Record<string, string> = {
+    "Authorization": `Bearer ${token}`,
+    "Dropbox-API-Arg": JSON.stringify(args),
+  };
+
+  let body: string | Uint8Array | undefined;
+  if (content) {
+    if (typeof content === "string") {
+      headers["Content-Type"] = "application/octet-stream";
+      body = content;
+    } else {
+      headers["Content-Type"] = "application/octet-stream";
+      body = content;
+    }
+  }
+
+  const response = await fetch(`${DROPBOX_CONTENT_URL}${endpoint}`, {
+    method: "POST",
+    headers,
+    body,
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Dropbox API error: ${response.status} ${error.error_summary || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+// Account Operations
+export function getCurrentAccount(): Promise<AccountInfo> {
+  return dropboxRPC<AccountInfo>("/users/get_current_account");
+}
+
+export function getSpaceUsage(): Promise<SpaceUsage> {
+  return dropboxRPC<SpaceUsage>("/users/get_space_usage");
+}
+
+// File and Folder Operations
+export function listFolder(
+  path: string = "",
+  options?: {
+    recursive?: boolean;
+    includeDeleted?: boolean;
+    includeHasExplicitSharedMembers?: boolean;
+    limit?: number;
+  },
+): Promise<ListFolderResult> {
+  return dropboxRPC<ListFolderResult>("/files/list_folder", {
+    path: path || "",
+    recursive: options?.recursive || false,
+    include_deleted: options?.includeDeleted || false,
+    include_has_explicit_shared_members: options?.includeHasExplicitSharedMembers || false,
+    limit: options?.limit || 100,
+  });
+}
+
+export function listFolderContinue(cursor: string): Promise<ListFolderResult> {
+  return dropboxRPC<ListFolderResult>("/files/list_folder/continue", { cursor });
+}
+
+export function getMetadata(
+  path: string,
+  options?: {
+    includeMediaInfo?: boolean;
+    includeDeleted?: boolean;
+  },
+): Promise<DropboxFileMetadata | DropboxFolderMetadata> {
+  return dropboxRPC<DropboxFileMetadata | DropboxFolderMetadata>("/files/get_metadata", {
+    path,
+    include_media_info: options?.includeMediaInfo || false,
+    include_deleted: options?.includeDeleted || false,
+  });
+}
+
+export async function downloadFile(path: string): Promise<{
+  content: string;
+  metadata: DropboxFileMetadata;
+}> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Dropbox. Please connect your account.");
+  }
+
+  const response = await fetch(`${DROPBOX_CONTENT_URL}/files/download`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Dropbox-API-Arg": JSON.stringify({ path }),
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Dropbox API error: ${response.status} ${error.error_summary || response.statusText}`,
+    );
+  }
+
+  const content = await response.text();
+  const metadataHeader = response.headers.get("Dropbox-API-Result");
+  const metadata = metadataHeader ? JSON.parse(metadataHeader) : {};
+
+  return { content, metadata };
+}
+
+export function uploadFile(
+  path: string,
+  content: string | Uint8Array,
+  options?: {
+    mode?: "add" | "overwrite" | "update";
+    autorename?: boolean;
+    mute?: boolean;
+  },
+): Promise<DropboxFileMetadata> {
+  return dropboxContent<DropboxFileMetadata>(
+    "/files/upload",
+    {
+      path,
+      mode: options?.mode || "add",
+      autorename: options?.autorename || false,
+      mute: options?.mute || false,
+    },
+    content,
+  );
+}
+
+export function deleteFile(
+  path: string,
+): Promise<DropboxFileMetadata | DropboxFolderMetadata> {
+  return dropboxRPC<DropboxFileMetadata | DropboxFolderMetadata>("/files/delete_v2", {
+    path,
+  }).then((result: any) => result.metadata);
+}
+
+export function moveFile(
+  fromPath: string,
+  toPath: string,
+  options?: {
+    allowSharedFolder?: boolean;
+    autorename?: boolean;
+    allowOwnershipTransfer?: boolean;
+  },
+): Promise<DropboxFileMetadata | DropboxFolderMetadata> {
+  return dropboxRPC<{ metadata: DropboxFileMetadata | DropboxFolderMetadata }>("/files/move_v2", {
+    from_path: fromPath,
+    to_path: toPath,
+    allow_shared_folder: options?.allowSharedFolder || false,
+    autorename: options?.autorename || false,
+    allow_ownership_transfer: options?.allowOwnershipTransfer || false,
+  }).then((result) => result.metadata);
+}
+
+export function copyFile(
+  fromPath: string,
+  toPath: string,
+  options?: {
+    allowSharedFolder?: boolean;
+    autorename?: boolean;
+    allowOwnershipTransfer?: boolean;
+  },
+): Promise<DropboxFileMetadata | DropboxFolderMetadata> {
+  return dropboxRPC<{ metadata: DropboxFileMetadata | DropboxFolderMetadata }>("/files/copy_v2", {
+    from_path: fromPath,
+    to_path: toPath,
+    allow_shared_folder: options?.allowSharedFolder || false,
+    autorename: options?.autorename || false,
+    allow_ownership_transfer: options?.allowOwnershipTransfer || false,
+  }).then((result) => result.metadata);
+}
+
+export function createFolder(
+  path: string,
+  autorename?: boolean,
+): Promise<DropboxFolderMetadata> {
+  return dropboxRPC<{ metadata: DropboxFolderMetadata }>("/files/create_folder_v2", {
+    path,
+    autorename: autorename || false,
+  }).then((result) => result.metadata);
+}
+
+// Search Operations
+export function searchFiles(
+  query: string,
+  options?: {
+    path?: string;
+    maxResults?: number;
+    fileCategories?: Array<
+      | "image"
+      | "document"
+      | "pdf"
+      | "spreadsheet"
+      | "presentation"
+      | "audio"
+      | "video"
+      | "folder"
+      | "paper"
+      | "others"
+    >;
+    fileExtensions?: string[];
+  },
+): Promise<SearchResult> {
+  return dropboxRPC<SearchResult>("/files/search_v2", {
+    query,
+    options: {
+      path: options?.path || "",
+      max_results: options?.maxResults || 20,
+      file_categories: options?.fileCategories,
+      filename_only: false,
+    },
+  });
+}
+
+// Sharing Operations
+export async function createSharedLink(
+  path: string,
+  settings?: {
+    requestedVisibility?: "public" | "team_only" | "password";
+    linkPassword?: string;
+    expires?: string;
+  },
+): Promise<SharedLinkMetadata> {
+  try {
+    return await dropboxRPC<SharedLinkMetadata>("/sharing/create_shared_link_with_settings", {
+      path,
+      settings: settings || {},
+    });
+  } catch (error) {
+    // If link already exists, get the existing link
+    if (error instanceof Error && error.message.includes("shared_link_already_exists")) {
+      const links = await listSharedLinks(path);
+      if (links.length > 0) {
+        return links[0];
+      }
+    }
+    throw error;
+  }
+}
+
+export async function listSharedLinks(path?: string): Promise<SharedLinkMetadata[]> {
+  const result = await dropboxRPC<{ links: SharedLinkMetadata[] }>("/sharing/list_shared_links", {
+    path: path || "",
+  });
+  return result.links;
+}
+
+// Helper Functions
+export function formatFileSize(bytes: number): string {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let size = bytes;
+  let unitIndex = 0;
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+
+  return `${size.toFixed(2)} ${units[unitIndex]}`;
+}
+
+export function isFile(metadata: DropboxMetadata): metadata is DropboxFileMetadata {
+  return metadata[".tag"] === "file";
+}
+
+export function isFolder(metadata: DropboxMetadata): metadata is DropboxFolderMetadata {
+  return metadata[".tag"] === "folder";
+}

package/dist/integrations/dropbox/files/lib/token-store.ts

@@ -0,0 +1,5 @@
+/**
+ * Dropbox Token Store
+ */
+
+export { memoryTokenStore as tokenStore, type OAuthTokens, type TokenStore } from "veryfront/oauth";