veryfront 0.0.49 → 0.0.50

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

@@ -0,0 +1,63 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatFileSize, isFile, isFolder, listFiles } from "../../lib/onedrive-client.ts";
+
+export default tool({
+  id: "list-files",
+  description:
+    "List files and folders in a OneDrive folder. Returns file/folder names, types, sizes, and modification dates.",
+  inputSchema: z.object({
+    folderId: z.string().default("root").describe(
+      'Folder ID or "root" for the root folder',
+    ),
+    orderBy: z.string().optional().describe(
+      'Order by field (e.g., "name", "lastModifiedDateTime desc")',
+    ),
+    limit: z.number().min(1).max(200).default(100).describe(
+      "Maximum number of items to return",
+    ),
+  }),
+  async execute({ folderId, orderBy, limit }) {
+    const result = await listFiles(folderId, {
+      orderBy,
+      top: limit,
+    });
+
+    const items = result.value.map((item) => {
+      const baseInfo = {
+        id: item.id,
+        name: item.name,
+        webUrl: item.webUrl,
+        createdDateTime: item.createdDateTime,
+        lastModifiedDateTime: item.lastModifiedDateTime,
+      };
+
+      if (isFile(item)) {
+        return {
+          ...baseInfo,
+          type: "file" as const,
+          size: item.size || 0,
+          sizeFormatted: formatFileSize(item.size || 0),
+          mimeType: item.file?.mimeType,
+        };
+      } else if (isFolder(item)) {
+        return {
+          ...baseInfo,
+          type: "folder" as const,
+          childCount: item.folder?.childCount || 0,
+        };
+      }
+
+      return {
+        ...baseInfo,
+        type: "unknown" as const,
+      };
+    });
+
+    return {
+      items,
+      count: items.length,
+      hasMore: !!result["@odata.nextLink"],
+    };
+  },
+});

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

@@ -0,0 +1,59 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatFileSize, isFile, isFolder, searchFiles } from "../../lib/onedrive-client.ts";
+
+export default tool({
+  id: "search-files",
+  description:
+    "Search for files and folders in OneDrive 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"),
+    maxResults: z.number().min(1).max(100).default(20).describe(
+      "Maximum number of results to return",
+    ),
+  }),
+  async execute({ query, maxResults }) {
+    const result = await searchFiles(query, {
+      top: maxResults,
+    });
+
+    const matches = result.value.map((item) => {
+      const baseInfo = {
+        id: item.id,
+        name: item.name,
+        webUrl: item.webUrl,
+        createdDateTime: item.createdDateTime,
+        lastModifiedDateTime: item.lastModifiedDateTime,
+        parentPath: item.parentReference?.path,
+      };
+
+      if (isFile(item)) {
+        return {
+          ...baseInfo,
+          type: "file" as const,
+          size: item.size || 0,
+          sizeFormatted: formatFileSize(item.size || 0),
+          mimeType: item.file?.mimeType,
+        };
+      } else if (isFolder(item)) {
+        return {
+          ...baseInfo,
+          type: "folder" as const,
+          childCount: item.folder?.childCount || 0,
+        };
+      }
+
+      return {
+        ...baseInfo,
+        type: "unknown" as const,
+      };
+    });
+
+    return {
+      matches,
+      count: matches.length,
+      hasMore: !!result["@odata.nextLink"],
+      query,
+    };
+  },
+});

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

@@ -0,0 +1,43 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatFileSize, uploadFile } from "../../lib/onedrive-client.ts";
+
+export default tool({
+  id: "upload-file",
+  description:
+    "Upload or update a file in OneDrive. Can create new files or overwrite existing ones.",
+  inputSchema: z.object({
+    fileName: z.string().describe(
+      "Name of the file to upload (e.g., 'notes.txt', 'document.pdf')",
+    ),
+    content: z.string().describe("The content to write to the file"),
+    parentFolderId: z.string().default("root").describe(
+      'Parent folder ID where the file should be uploaded (default: "root")',
+    ),
+  }),
+  async execute({ fileName, content, parentFolderId }) {
+    // Validate filename
+    if (!fileName || fileName.trim().length === 0) {
+      throw new Error("Filename cannot be empty");
+    }
+
+    if (fileName.includes("/") || fileName.includes("\\")) {
+      throw new Error("Filename cannot contain path separators");
+    }
+
+    // Upload the file
+    const result = await uploadFile(fileName, content, parentFolderId);
+
+    return {
+      success: true,
+      id: result.id,
+      name: result.name,
+      webUrl: result.webUrl,
+      size: result.size || 0,
+      sizeFormatted: formatFileSize(result.size || 0),
+      createdDateTime: result.createdDateTime,
+      lastModifiedDateTime: result.lastModifiedDateTime,
+      message: `File uploaded successfully: ${result.name}`,
+    };
+  },
+});

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

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

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

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

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

@@ -0,0 +1,314 @@
+import { getAccessToken } from "./token-store.ts";
+
+const GRAPH_API_URL = "https://graph.microsoft.com/v1.0";
+
+// OneDrive API Types (Microsoft Graph API)
+export interface DriveItem {
+  id: string;
+  name: string;
+  size?: number;
+  createdDateTime: string;
+  lastModifiedDateTime: string;
+  webUrl: string;
+  parentReference?: {
+    driveId: string;
+    id: string;
+    path: string;
+  };
+  file?: {
+    mimeType: string;
+    hashes?: {
+      quickXorHash?: string;
+      sha1Hash?: string;
+      sha256Hash?: string;
+    };
+  };
+  folder?: {
+    childCount: number;
+  };
+  "@microsoft.graph.downloadUrl"?: string;
+}
+
+export interface FileMetadata {
+  id: string;
+  name: string;
+  size: number;
+  mimeType: string;
+  createdDateTime: string;
+  lastModifiedDateTime: string;
+  webUrl: string;
+  downloadUrl?: string;
+}
+
+export interface FolderMetadata {
+  id: string;
+  name: string;
+  childCount: number;
+  createdDateTime: string;
+  lastModifiedDateTime: string;
+  webUrl: string;
+}
+
+export interface ListFilesResult {
+  value: DriveItem[];
+  "@odata.nextLink"?: string;
+}
+
+export interface SearchResult {
+  value: DriveItem[];
+  "@odata.nextLink"?: string;
+}
+
+// Helper function for OneDrive API calls
+async function onedriveFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with OneDrive. Please connect your account.");
+  }
+
+  const url = endpoint.startsWith("http") ? endpoint : `${GRAPH_API_URL}${endpoint}`;
+
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `OneDrive API error: ${response.status} ${error.error?.message || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+// File and Folder Operations
+
+/**
+ * List files in a folder
+ * @param folderId Folder ID or path (use "root" for root folder)
+ */
+export function listFiles(
+  folderId: string = "root",
+  options?: {
+    orderBy?: string;
+    top?: number;
+    select?: string[];
+  },
+): Promise<ListFilesResult> {
+  const params = new URLSearchParams();
+
+  if (options?.orderBy) {
+    params.set("$orderby", options.orderBy);
+  }
+  if (options?.top) {
+    params.set("$top", options.top.toString());
+  }
+  if (options?.select) {
+    params.set("$select", options.select.join(","));
+  }
+
+  const queryString = params.toString();
+  const endpoint = `/me/drive/items/${folderId}/children${queryString ? `?${queryString}` : ""}`;
+
+  return onedriveFetch<ListFilesResult>(endpoint);
+}
+
+/**
+ * Get file or folder metadata
+ */
+export function getFile(itemId: string): Promise<DriveItem> {
+  return onedriveFetch<DriveItem>(`/me/drive/items/${itemId}`);
+}
+
+/**
+ * Download file content
+ */
+export async function downloadFile(itemId: string): Promise<{
+  content: string;
+  metadata: FileMetadata;
+}> {
+  const item = await getFile(itemId);
+
+  if (!item.file) {
+    throw new Error("Item is not a file");
+  }
+
+  const downloadUrl = item["@microsoft.graph.downloadUrl"];
+  if (!downloadUrl) {
+    throw new Error("Download URL not available");
+  }
+
+  const response = await fetch(downloadUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to download file: ${response.statusText}`);
+  }
+
+  const content = await response.text();
+
+  const metadata: FileMetadata = {
+    id: item.id,
+    name: item.name,
+    size: item.size || 0,
+    mimeType: item.file.mimeType,
+    createdDateTime: item.createdDateTime,
+    lastModifiedDateTime: item.lastModifiedDateTime,
+    webUrl: item.webUrl,
+    downloadUrl,
+  };
+
+  return { content, metadata };
+}
+
+/**
+ * Upload file
+ * For files smaller than 4MB, use simple upload
+ */
+export async function uploadFile(
+  fileName: string,
+  content: string,
+  parentFolderId: string = "root",
+): Promise<DriveItem> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with OneDrive. Please connect your account.");
+  }
+
+  const endpoint = `${GRAPH_API_URL}/me/drive/items/${parentFolderId}:/${fileName}:/content`;
+
+  const response = await fetch(endpoint, {
+    method: "PUT",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/octet-stream",
+    },
+    body: content,
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Failed to upload file: ${error.error?.message || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * Create folder
+ */
+export function createFolder(
+  folderName: string,
+  parentFolderId: string = "root",
+): Promise<DriveItem> {
+  return onedriveFetch<DriveItem>(`/me/drive/items/${parentFolderId}/children`, {
+    method: "POST",
+    body: JSON.stringify({
+      name: folderName,
+      folder: {},
+      "@microsoft.graph.conflictBehavior": "rename",
+    }),
+  });
+}
+
+/**
+ * Search files
+ */
+export function searchFiles(
+  query: string,
+  options?: {
+    top?: number;
+  },
+): Promise<SearchResult> {
+  const params = new URLSearchParams({
+    q: query,
+  });
+
+  if (options?.top) {
+    params.set("$top", options.top.toString());
+  }
+
+  return onedriveFetch<SearchResult>(
+    `/me/drive/root/search(q='${encodeURIComponent(query)}')?${params.toString()}`,
+  );
+}
+
+/**
+ * Delete file or folder
+ */
+export async function deleteFile(itemId: string): Promise<void> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with OneDrive. Please connect your account.");
+  }
+
+  const response = await fetch(`${GRAPH_API_URL}/me/drive/items/${itemId}`, {
+    method: "DELETE",
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Failed to delete item: ${error.error?.message || response.statusText}`,
+    );
+  }
+}
+
+/**
+ * Move file or folder
+ */
+export function moveFile(
+  itemId: string,
+  newParentId: string,
+  newName?: string,
+): Promise<DriveItem> {
+  const body: Record<string, unknown> = {
+    parentReference: {
+      id: newParentId,
+    },
+  };
+
+  if (newName) {
+    body.name = newName;
+  }
+
+  return onedriveFetch<DriveItem>(`/me/drive/items/${itemId}`, {
+    method: "PATCH",
+    body: JSON.stringify(body),
+  });
+}
+
+// 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(item: DriveItem): boolean {
+  return item.file !== undefined;
+}
+
+export function isFolder(item: DriveItem): boolean {
+  return item.folder !== undefined;
+}

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

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