veryfront 0.0.49 → 0.0.51

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

@@ -0,0 +1,63 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listFiles, searchFiles } from "../../lib/sharepoint-client.ts";
+
+export default tool({
+  id: "list-files",
+  description:
+    "List files and folders in a SharePoint document library. Can list root level or a specific folder, or search across the entire library.",
+  inputSchema: z.object({
+    siteId: z.string().describe("The ID of the SharePoint site"),
+    driveId: z.string().describe("The ID of the document library (drive)"),
+    folderId: z.string().optional().describe(
+      "Optional folder ID to list contents from. If not provided, lists root level.",
+    ),
+    search: z.string().optional().describe(
+      "Optional search query to find files by name or content instead of listing",
+    ),
+    orderBy: z.enum(["name", "lastModifiedDateTime", "size"]).optional().describe(
+      "Sort order for results",
+    ),
+    limit: z.number().min(1).max(100).default(50).describe("Maximum number of items to return"),
+  }),
+  async execute({ siteId, driveId, folderId, search, orderBy, limit }) {
+    let files;
+
+    if (search) {
+      // Use search functionality
+      files = await searchFiles(siteId, search, { limit });
+    } else {
+      // List files in folder
+      files = await listFiles(siteId, driveId, folderId, {
+        limit,
+        orderBy,
+      });
+    }
+
+    return files.map((file) => ({
+      id: file.id,
+      name: file.name,
+      type: file.folder ? "folder" : "file",
+      size: file.size,
+      sizeFormatted: formatBytes(file.size),
+      mimeType: file.file?.mimeType,
+      url: file.webUrl,
+      created: file.createdDateTime,
+      lastModified: file.lastModifiedDateTime,
+      createdBy: file.createdBy?.user?.displayName,
+      lastModifiedBy: file.lastModifiedBy?.user?.displayName,
+      parentPath: file.parentReference?.path,
+      childCount: file.folder?.childCount,
+    }));
+  },
+});
+
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return "0 Bytes";
+
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + " " + sizes[i];
+}

package/dist/integrations/sharepoint/files/ai/tools/list-sites.ts

@@ -0,0 +1,28 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listSites } from "../../lib/sharepoint-client.ts";
+
+export default tool({
+  id: "list-sites",
+  description:
+    "List all SharePoint sites the user has access to. Returns site names, URLs, and IDs.",
+  inputSchema: z.object({
+    search: z.string().optional().describe(
+      "Optional search query to filter sites by name or description",
+    ),
+    limit: z.number().min(1).max(50).default(20).describe("Maximum number of sites to return"),
+  }),
+  async execute({ search, limit }) {
+    const sites = await listSites({ search, limit });
+
+    return sites.map((site) => ({
+      id: site.id,
+      name: site.displayName || site.name,
+      description: site.description,
+      url: site.webUrl,
+      hostname: site.siteCollection?.hostname,
+      created: site.createdDateTime,
+      lastModified: site.lastModifiedDateTime,
+    }));
+  },
+});

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

@@ -0,0 +1,72 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createFolder, uploadFile } from "../../lib/sharepoint-client.ts";
+
+export default tool({
+  id: "upload-file",
+  description:
+    "Upload a file to a SharePoint document library. Can upload to root or a specific folder.",
+  inputSchema: z.object({
+    siteId: z.string().describe("The ID of the SharePoint site"),
+    driveId: z.string().describe("The ID of the document library (drive) to upload to"),
+    fileName: z.string().describe("The name of the file to create (including extension)"),
+    content: z.string().describe("The content of the file to upload"),
+    folderId: z.string().optional().describe(
+      "Optional folder ID to upload into. If not provided, uploads to root.",
+    ),
+    createFolderIfNeeded: z.boolean().default(false).describe(
+      "If true and folderPath is provided, creates the folder if it does not exist",
+    ),
+    folderPath: z.string().optional().describe(
+      'Optional folder path (e.g., "Documents/Projects") to create if createFolderIfNeeded is true',
+    ),
+  }),
+  async execute(
+    { siteId, driveId, fileName, content, folderId, createFolderIfNeeded, folderPath },
+  ) {
+    let targetFolderId = folderId;
+
+    // Create folder if needed
+    if (createFolderIfNeeded && folderPath && !folderId) {
+      const folders = folderPath.split("/").filter(Boolean);
+      let currentFolderId: string | undefined;
+
+      for (const folderName of folders) {
+        try {
+          const folder = await createFolder(siteId, driveId, folderName, currentFolderId);
+          currentFolderId = folder.id;
+        } catch (error) {
+          // Folder might already exist, try to continue
+          console.warn(`Note: Could not create folder "${folderName}":`, error);
+        }
+      }
+
+      targetFolderId = currentFolderId;
+    }
+
+    const file = await uploadFile(siteId, driveId, fileName, content, targetFolderId);
+
+    return {
+      id: file.id,
+      name: file.name,
+      size: file.size,
+      sizeFormatted: formatBytes(file.size),
+      mimeType: file.file?.mimeType,
+      url: file.webUrl,
+      created: file.createdDateTime,
+      lastModified: file.lastModifiedDateTime,
+      parentPath: file.parentReference?.path,
+      message: `Successfully uploaded "${fileName}" to SharePoint`,
+    };
+  },
+});
+
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return "0 Bytes";
+
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + " " + sizes[i];
+}

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

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

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

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

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

@@ -0,0 +1,420 @@
+import { getAccessToken } from "./token-store.ts";
+
+const GRAPH_BASE_URL = "https://graph.microsoft.com/v1.0";
+
+// Type definitions for SharePoint responses
+export interface SharePointSite {
+  id: string;
+  name: string;
+  displayName: string;
+  description?: string;
+  webUrl: string;
+  createdDateTime: string;
+  lastModifiedDateTime: string;
+  siteCollection?: {
+    hostname: string;
+  };
+}
+
+export interface SharePointDrive {
+  id: string;
+  name: string;
+  description?: string;
+  driveType: string;
+  createdDateTime: string;
+  lastModifiedDateTime: string;
+  webUrl: string;
+  quota?: {
+    total: number;
+    used: number;
+    remaining: number;
+  };
+}
+
+export interface SharePointFile {
+  id: string;
+  name: string;
+  size: number;
+  createdDateTime: string;
+  lastModifiedDateTime: string;
+  webUrl: string;
+  file?: {
+    mimeType: string;
+    hashes?: {
+      sha1Hash?: string;
+      quickXorHash?: string;
+    };
+  };
+  folder?: {
+    childCount: number;
+  };
+  parentReference?: {
+    driveId: string;
+    id: string;
+    path: string;
+  };
+  createdBy?: {
+    user?: {
+      displayName: string;
+      email?: string;
+    };
+  };
+  lastModifiedBy?: {
+    user?: {
+      displayName: string;
+      email?: string;
+    };
+  };
+}
+
+interface GraphResponse<T> {
+  value: T[];
+  "@odata.nextLink"?: string;
+}
+
+async function graphFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Microsoft. Please connect your account.");
+  }
+
+  const response = await fetch(`${GRAPH_BASE_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Microsoft Graph API error: ${response.status} ${
+        error.error?.message || response.statusText
+      }`,
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * List all SharePoint sites the user has access to
+ */
+export async function listSites(options?: {
+  search?: string;
+  limit?: number;
+}): Promise<SharePointSite[]> {
+  let endpoint = "/sites?search=*";
+
+  if (options?.search) {
+    endpoint = `/sites?search=${encodeURIComponent(options.search)}`;
+  }
+
+  const response = await graphFetch<GraphResponse<SharePointSite>>(endpoint);
+  const sites = response.value || [];
+
+  if (options?.limit) {
+    return sites.slice(0, options.limit);
+  }
+
+  return sites;
+}
+
+/**
+ * Get details about a specific SharePoint site
+ */
+export function getSite(siteId: string): Promise<SharePointSite> {
+  return graphFetch<SharePointSite>(`/sites/${siteId}`);
+}
+
+/**
+ * Get a site by hostname and path
+ */
+export function getSiteByPath(
+  hostname: string,
+  sitePath: string,
+): Promise<SharePointSite> {
+  return graphFetch<SharePointSite>(
+    `/sites/${hostname}:${sitePath}`,
+  );
+}
+
+/**
+ * List all document libraries (drives) in a site
+ */
+export async function listDrives(siteId: string): Promise<SharePointDrive[]> {
+  const response = await graphFetch<GraphResponse<SharePointDrive>>(
+    `/sites/${siteId}/drives`,
+  );
+  return response.value || [];
+}
+
+/**
+ * Get the default document library for a site
+ */
+export function getDefaultDrive(siteId: string): Promise<SharePointDrive> {
+  return graphFetch<SharePointDrive>(`/sites/${siteId}/drive`);
+}
+
+/**
+ * List files and folders in a drive or folder
+ */
+export async function listFiles(
+  siteId: string,
+  driveId: string,
+  folderId?: string,
+  options?: {
+    limit?: number;
+    orderBy?: string;
+  },
+): Promise<SharePointFile[]> {
+  let endpoint = folderId
+    ? `/sites/${siteId}/drives/${driveId}/items/${folderId}/children`
+    : `/sites/${siteId}/drives/${driveId}/root/children`;
+
+  if (options?.orderBy) {
+    endpoint += `?$orderby=${options.orderBy}`;
+  }
+
+  if (options?.limit) {
+    endpoint += `${options.orderBy ? "&" : "?"}$top=${options.limit}`;
+  }
+
+  const response = await graphFetch<GraphResponse<SharePointFile>>(endpoint);
+  return response.value || [];
+}
+
+/**
+ * Get file metadata
+ */
+export function getFile(
+  siteId: string,
+  driveId: string,
+  itemId: string,
+): Promise<SharePointFile> {
+  return graphFetch<SharePointFile>(
+    `/sites/${siteId}/drives/${driveId}/items/${itemId}`,
+  );
+}
+
+/**
+ * Get file by path
+ */
+export function getFileByPath(
+  siteId: string,
+  driveId: string,
+  path: string,
+): Promise<SharePointFile> {
+  const encodedPath = encodeURIComponent(path);
+  return graphFetch<SharePointFile>(
+    `/sites/${siteId}/drives/${driveId}/root:/${encodedPath}`,
+  );
+}
+
+/**
+ * Download file content
+ */
+export async function downloadFile(
+  siteId: string,
+  driveId: string,
+  itemId: string,
+): Promise<ArrayBuffer> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Microsoft. Please connect your account.");
+  }
+
+  const _metadata = await getFile(siteId, driveId, itemId);
+
+  // Get download URL
+  const downloadUrl = `${GRAPH_BASE_URL}/sites/${siteId}/drives/${driveId}/items/${itemId}/content`;
+
+  const response = await fetch(downloadUrl, {
+    headers: {
+      "Authorization": `Bearer ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to download file: ${response.statusText}`);
+  }
+
+  return response.arrayBuffer();
+}
+
+/**
+ * Download file content as text
+ */
+export async function downloadFileAsText(
+  siteId: string,
+  driveId: string,
+  itemId: string,
+): Promise<string> {
+  const buffer = await downloadFile(siteId, driveId, itemId);
+  return new TextDecoder().decode(buffer);
+}
+
+/**
+ * Upload a file to a folder
+ */
+export async function uploadFile(
+  siteId: string,
+  driveId: string,
+  fileName: string,
+  content: string | ArrayBuffer | Blob,
+  folderId?: string,
+): Promise<SharePointFile> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Microsoft. Please connect your account.");
+  }
+
+  const encodedFileName = encodeURIComponent(fileName);
+  const endpoint = folderId
+    ? `/sites/${siteId}/drives/${driveId}/items/${folderId}:/${encodedFileName}:/content`
+    : `/sites/${siteId}/drives/${driveId}/root:/${encodedFileName}:/content`;
+
+  let body: ArrayBuffer;
+  if (typeof content === "string") {
+    body = new TextEncoder().encode(content);
+  } else if (content instanceof Blob) {
+    body = await content.arrayBuffer();
+  } else {
+    body = content;
+  }
+
+  const response = await fetch(`${GRAPH_BASE_URL}${endpoint}`, {
+    method: "PUT",
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/octet-stream",
+    },
+    body,
+  });
+
+  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 a folder
+ */
+export function createFolder(
+  siteId: string,
+  driveId: string,
+  folderName: string,
+  parentFolderId?: string,
+): Promise<SharePointFile> {
+  const endpoint = parentFolderId
+    ? `/sites/${siteId}/drives/${driveId}/items/${parentFolderId}/children`
+    : `/sites/${siteId}/drives/${driveId}/root/children`;
+
+  return graphFetch<SharePointFile>(endpoint, {
+    method: "POST",
+    body: JSON.stringify({
+      name: folderName,
+      folder: {},
+      "@microsoft.graph.conflictBehavior": "rename",
+    }),
+  });
+}
+
+/**
+ * Search for files in a site
+ */
+export async function searchFiles(
+  siteId: string,
+  query: string,
+  options?: {
+    limit?: number;
+  },
+): Promise<SharePointFile[]> {
+  let endpoint = `/sites/${siteId}/drive/root/search(q='${encodeURIComponent(query)}')`;
+
+  if (options?.limit) {
+    endpoint += `?$top=${options.limit}`;
+  }
+
+  const response = await graphFetch<GraphResponse<SharePointFile>>(endpoint);
+  return response.value || [];
+}
+
+/**
+ * Delete a file or folder
+ */
+export async function deleteItem(
+  siteId: string,
+  driveId: string,
+  itemId: string,
+): Promise<void> {
+  await graphFetch<void>(
+    `/sites/${siteId}/drives/${driveId}/items/${itemId}`,
+    { method: "DELETE" },
+  );
+}
+
+/**
+ * Move or rename a file or folder
+ */
+export function moveItem(
+  siteId: string,
+  driveId: string,
+  itemId: string,
+  newParentId: string,
+  newName?: string,
+): Promise<SharePointFile> {
+  const body: { parentReference: { id: string }; name?: string } = {
+    parentReference: { id: newParentId },
+  };
+
+  if (newName) {
+    body.name = newName;
+  }
+
+  return graphFetch<SharePointFile>(
+    `/sites/${siteId}/drives/${driveId}/items/${itemId}`,
+    {
+      method: "PATCH",
+      body: JSON.stringify(body),
+    },
+  );
+}
+
+/**
+ * Copy a file or folder
+ */
+export async function copyItem(
+  siteId: string,
+  driveId: string,
+  itemId: string,
+  newParentId: string,
+  newName?: string,
+): Promise<void> {
+  const body: { parentReference: { driveId: string; id: string }; name?: string } = {
+    parentReference: { driveId, id: newParentId },
+  };
+
+  if (newName) {
+    body.name = newName;
+  }
+
+  // Copy is async, returns 202 Accepted with a Location header
+  await graphFetch<void>(
+    `/sites/${siteId}/drives/${driveId}/items/${itemId}/copy`,
+    {
+      method: "POST",
+      body: JSON.stringify(body),
+    },
+  );
+}