veryfront 0.0.49 → 0.0.50

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

@@ -0,0 +1,93 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { downloadFileAsText, getFile } from "../../lib/sharepoint-client.ts";
+
+export default tool({
+  id: "get-file",
+  description:
+    "Get detailed metadata and optionally download content of a file from SharePoint. Can retrieve text content for text-based files.",
+  inputSchema: z.object({
+    siteId: z.string().describe("The ID of the SharePoint site"),
+    driveId: z.string().describe("The ID of the document library (drive)"),
+    itemId: z.string().describe("The ID of the file to retrieve"),
+    includeContent: z.boolean().default(false).describe(
+      "Whether to download and include the file content (only works for text-based files)",
+    ),
+    contentMaxLength: z.number().min(100).max(100000).default(50000).describe(
+      "Maximum length of content to return if includeContent is true",
+    ),
+  }),
+  async execute({ siteId, driveId, itemId, includeContent, contentMaxLength }) {
+    const file = await getFile(siteId, driveId, itemId);
+
+    const result: Record<string, unknown> = {
+      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,
+      createdBy: {
+        name: file.createdBy?.user?.displayName,
+        email: file.createdBy?.user?.email,
+      },
+      lastModifiedBy: {
+        name: file.lastModifiedBy?.user?.displayName,
+        email: file.lastModifiedBy?.user?.email,
+      },
+      parentReference: {
+        driveId: file.parentReference?.driveId,
+        id: file.parentReference?.id,
+        path: file.parentReference?.path,
+      },
+      hashes: file.file?.hashes,
+    };
+
+    // Only try to download content for text-based files
+    if (includeContent && file.file?.mimeType) {
+      const textMimeTypes = [
+        "text/",
+        "application/json",
+        "application/xml",
+        "application/javascript",
+        "application/typescript",
+      ];
+
+      const isTextFile = textMimeTypes.some((type) => file.file!.mimeType.startsWith(type));
+
+      if (isTextFile && file.size < contentMaxLength) {
+        try {
+          const content = await downloadFileAsText(siteId, driveId, itemId);
+          result.content = content.length > contentMaxLength
+            ? content.substring(0, contentMaxLength) + "\n\n[Content truncated...]"
+            : content;
+          result.contentTruncated = content.length > contentMaxLength;
+        } catch (error) {
+          result.contentError = `Failed to download content: ${
+            error instanceof Error ? error.message : "Unknown error"
+          }`;
+        }
+      } else if (!isTextFile) {
+        result.contentError = "File is not a text-based file type";
+      } else if (file.size >= contentMaxLength) {
+        result.contentError = `File size (${
+          formatBytes(file.size)
+        }) exceeds maximum content length`;
+      }
+    }
+
+    return result;
+  },
+});
+
+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/get-site.ts

@@ -0,0 +1,51 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getSite, listDrives } from "../../lib/sharepoint-client.ts";
+
+export default tool({
+  id: "get-site",
+  description:
+    "Get detailed information about a specific SharePoint site including its document libraries (drives).",
+  inputSchema: z.object({
+    siteId: z.string().describe("The ID of the SharePoint site to retrieve"),
+    includeDrives: z.boolean().default(true).describe(
+      "Whether to include the list of document libraries in the response",
+    ),
+  }),
+  async execute({ siteId, includeDrives }) {
+    const site = await getSite(siteId);
+
+    const result: Record<string, unknown> = {
+      id: site.id,
+      name: site.displayName || site.name,
+      description: site.description,
+      url: site.webUrl,
+      hostname: site.siteCollection?.hostname,
+      created: site.createdDateTime,
+      lastModified: site.lastModifiedDateTime,
+    };
+
+    if (includeDrives) {
+      const drives = await listDrives(siteId);
+      result.documentLibraries = drives.map((drive) => ({
+        id: drive.id,
+        name: drive.name,
+        description: drive.description,
+        type: drive.driveType,
+        url: drive.webUrl,
+        quota: drive.quota
+          ? {
+            total: drive.quota.total,
+            used: drive.quota.used,
+            remaining: drive.quota.remaining,
+            percentUsed: drive.quota.total > 0
+              ? Math.round((drive.quota.used / drive.quota.total) * 100)
+              : 0,
+          }
+          : undefined,
+      }));
+    }
+
+    return result;
+  },
+});

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