veryfront 0.0.48 → 0.0.50

package/dist/integrations/notion/connector.json

@@ -0,0 +1,87 @@
+{
+  "name": "notion",
+  "displayName": "Notion",
+  "icon": "notion.svg",
+  "description": "Search, read, and create pages in Notion workspaces",
+  "auth": {
+    "type": "oauth2",
+    "provider": "notion",
+    "authorizationUrl": "https://api.notion.com/v1/oauth/authorize",
+    "tokenUrl": "https://api.notion.com/v1/oauth/token",
+    "scopes": [],
+    "callbackPath": "/api/auth/notion/callback",
+    "tokenAuthMethod": "basic",
+    "requiredApis": [
+      {
+        "name": "Notion Integration",
+        "enableUrl": "https://www.notion.so/my-integrations"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "NOTION_CLIENT_ID",
+      "description": "Notion OAuth Client ID (from your integration)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://www.notion.so/my-integrations"
+    },
+    {
+      "name": "NOTION_CLIENT_SECRET",
+      "description": "Notion OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://www.notion.so/my-integrations"
+    }
+  ],
+  "tools": [
+    {
+      "id": "search-notion",
+      "name": "Search Notion",
+      "description": "Search pages and databases in the workspace",
+      "requiresWrite": false
+    },
+    {
+      "id": "read-page",
+      "name": "Read Page",
+      "description": "Read the content of a Notion page",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-page",
+      "name": "Create Page",
+      "description": "Create a new page in a database or as a subpage",
+      "requiresWrite": true
+    },
+    {
+      "id": "query-database",
+      "name": "Query Database",
+      "description": "Query a Notion database with filters and sorts",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "search-docs",
+      "title": "Search my docs",
+      "prompt": "Search my Notion workspace for relevant documentation or notes about a topic.",
+      "category": "productivity",
+      "icon": "search"
+    },
+    {
+      "id": "summarize-page",
+      "title": "Summarize a page",
+      "prompt": "Read and summarize a specific Notion page. Extract the key points and action items.",
+      "category": "productivity",
+      "icon": "document"
+    },
+    {
+      "id": "create-meeting-notes",
+      "title": "Create meeting notes",
+      "prompt": "Create a new meeting notes page with today's date, attendees, agenda, and action items sections.",
+      "category": "productivity",
+      "icon": "plus"
+    }
+  ],
+  "suggestedWith": ["gmail", "slack", "calendar"]
+}

package/dist/integrations/notion/files/_env.example

@@ -0,0 +1,6 @@
+# Notion Integration
+# Create an integration at https://www.notion.so/my-integrations
+# Make sure to enable "Public Integration" for OAuth
+
+NOTION_CLIENT_ID=your_client_id_here
+NOTION_CLIENT_SECRET=your_client_secret_here

package/dist/integrations/notion/files/ai/tools/create-page.ts

@@ -0,0 +1,32 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createPage, getPageTitle } from "../../lib/notion-client.ts";
+
+export default tool({
+  id: "create-page",
+  description:
+    "Create a new page in Notion. Can create as a subpage of an existing page or as a new entry in a database.",
+  inputSchema: z.object({
+    parentId: z.string().describe("The ID of the parent page or database"),
+    parentType: z.enum(["page", "database"]).describe("Whether the parent is a page or database"),
+    title: z.string().describe("Title of the new page"),
+    content: z.string().optional().describe(
+      "Initial content for the page (plain text, paragraphs separated by double newlines)",
+    ),
+  }),
+  async execute({ parentId, parentType, title, content }) {
+    const page = await createPage({
+      parentId,
+      parentType,
+      title,
+      content,
+    });
+
+    return {
+      id: page.id,
+      title: getPageTitle(page),
+      url: page.url,
+      createdAt: page.created_time,
+    };
+  },
+});

package/dist/integrations/notion/files/ai/tools/query-database.ts

@@ -0,0 +1,44 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getPageTitle, queryDatabase } from "../../lib/notion-client.ts";
+
+export default tool({
+  id: "query-database",
+  description: "Query a Notion database to retrieve entries. Supports filtering and sorting.",
+  inputSchema: z.object({
+    databaseId: z.string().describe("The ID of the Notion database to query"),
+    sortProperty: z.string().optional().describe("Property name to sort by"),
+    sortDirection: z.enum(["ascending", "descending"]).default("descending").describe(
+      "Sort direction",
+    ),
+    limit: z.number().min(1).max(50).default(20).describe("Maximum number of results"),
+  }),
+  async execute({ databaseId, sortProperty, sortDirection, limit }) {
+    const sorts = sortProperty ? [{ property: sortProperty, direction: sortDirection }] : undefined;
+
+    const results = await queryDatabase(databaseId, {
+      sorts,
+      pageSize: limit,
+    });
+
+    return results.map((page) => {
+      // Extract all text properties
+      const properties: Record<string, string> = {};
+      for (const [key, prop] of Object.entries(page.properties)) {
+        if (prop.type === "title" && prop.title) {
+          properties[key] = prop.title.map((t) => t.plain_text).join("");
+        } else if (prop.type === "rich_text" && prop.rich_text) {
+          properties[key] = prop.rich_text.map((t) => t.plain_text).join("");
+        }
+      }
+
+      return {
+        id: page.id,
+        title: getPageTitle(page),
+        url: page.url,
+        properties,
+        lastEdited: page.last_edited_time,
+      };
+    });
+  },
+});

package/dist/integrations/notion/files/ai/tools/read-page.ts

@@ -0,0 +1,34 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import {
+  extractPlainText,
+  getPage,
+  getPageContent,
+  getPageTitle,
+} from "../../lib/notion-client.ts";
+
+export default tool({
+  id: "read-page",
+  description: "Read the content of a Notion page. Returns the page title and text content.",
+  inputSchema: z.object({
+    pageId: z.string().describe("The ID of the Notion page to read"),
+  }),
+  async execute({ pageId }) {
+    const [page, blocks] = await Promise.all([
+      getPage(pageId),
+      getPageContent(pageId),
+    ]);
+
+    const title = getPageTitle(page);
+    const content = extractPlainText(blocks);
+
+    return {
+      id: page.id,
+      title,
+      url: page.url,
+      content,
+      lastEdited: page.last_edited_time,
+      createdAt: page.created_time,
+    };
+  },
+});

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

@@ -0,0 +1,51 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getPageTitle, searchNotion } from "../../lib/notion-client.ts";
+
+export default tool({
+  id: "search-notion",
+  description:
+    "Search for pages and databases in the connected Notion workspace. Returns matching pages with their titles and IDs.",
+  inputSchema: z.object({
+    query: z.string().describe("Search query to find pages or databases"),
+    type: z.enum(["page", "database", "all"]).default("all").describe(
+      "Type of objects to search for",
+    ),
+    limit: z.number().min(1).max(20).default(10).describe("Maximum number of results to return"),
+  }),
+  async execute({ query, type, limit }) {
+    const filter = type === "all"
+      ? undefined
+      : { property: "object" as const, value: type as "page" | "database" };
+
+    const results = await searchNotion(query, {
+      filter,
+      pageSize: limit,
+    });
+
+    return results.map((item) => {
+      if (item.object === "page") {
+        return {
+          id: item.id,
+          type: "page",
+          title: getPageTitle(item),
+          url: item.url,
+          lastEdited: item.last_edited_time,
+        };
+      } else {
+        const db = item as {
+          id: string;
+          object: string;
+          title: Array<{ plain_text: string }>;
+          url?: string;
+        };
+        return {
+          id: db.id,
+          type: "database",
+          title: db.title.map((t) => t.plain_text).join(""),
+          url: db.url,
+        };
+      }
+    });
+  },
+});

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

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

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

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

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

@@ -0,0 +1,218 @@
+import { getAccessToken } from "./token-store.ts";
+
+const NOTION_API_VERSION = "2022-06-28";
+const NOTION_BASE_URL = "https://api.notion.com/v1";
+
+interface NotionResponse<T> {
+  object: string;
+  results?: T[];
+  next_cursor?: string | null;
+  has_more?: boolean;
+}
+
+interface NotionPage {
+  id: string;
+  object: "page";
+  created_time: string;
+  last_edited_time: string;
+  parent: { type: string; database_id?: string; page_id?: string };
+  properties: Record<string, NotionProperty>;
+  url: string;
+}
+
+interface NotionDatabase {
+  id: string;
+  object: "database";
+  title: Array<{ plain_text: string }>;
+  properties: Record<string, { type: string }>;
+}
+
+interface NotionBlock {
+  id: string;
+  type: string;
+  [key: string]: unknown;
+}
+
+interface NotionProperty {
+  type: string;
+  title?: Array<{ plain_text: string }>;
+  rich_text?: Array<{ plain_text: string }>;
+  [key: string]: unknown;
+}
+
+async function notionFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Notion. Please connect your account.");
+  }
+
+  const response = await fetch(`${NOTION_BASE_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Notion-Version": NOTION_API_VERSION,
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Notion API error: ${response.status} ${error.message || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function searchNotion(
+  query: string,
+  options?: {
+    filter?: { property: "object"; value: "page" | "database" };
+    pageSize?: number;
+  },
+): Promise<Array<NotionPage | NotionDatabase>> {
+  const body: Record<string, unknown> = { query };
+
+  if (options?.filter) {
+    body.filter = options.filter;
+  }
+  if (options?.pageSize) {
+    body.page_size = options.pageSize;
+  }
+
+  const response = await notionFetch<NotionResponse<NotionPage | NotionDatabase>>(
+    "/search",
+    { method: "POST", body: JSON.stringify(body) },
+  );
+
+  return response.results || [];
+}
+
+export function getPage(pageId: string): Promise<NotionPage> {
+  return notionFetch<NotionPage>(`/pages/${pageId}`);
+}
+
+export async function getPageContent(pageId: string): Promise<NotionBlock[]> {
+  const response = await notionFetch<NotionResponse<NotionBlock>>(
+    `/blocks/${pageId}/children`,
+  );
+  return response.results || [];
+}
+
+export function queryDatabase(
+  databaseId: string,
+  options?: {
+    filter?: Record<string, unknown>;
+    sorts?: Array<{ property: string; direction: "ascending" | "descending" }>;
+    pageSize?: number;
+  },
+): Promise<NotionPage[]> {
+  const body: Record<string, unknown> = {};
+
+  if (options?.filter) {
+    body.filter = options.filter;
+  }
+  if (options?.sorts) {
+    body.sorts = options.sorts;
+  }
+  if (options?.pageSize) {
+    body.page_size = options.pageSize;
+  }
+
+  return notionFetch<NotionResponse<NotionPage>>(
+    `/databases/${databaseId}/query`,
+    { method: "POST", body: JSON.stringify(body) },
+  ).then((response) => response.results || []);
+}
+
+export function createPage(options: {
+  parentId: string;
+  parentType: "database" | "page";
+  title: string;
+  content?: string;
+  properties?: Record<string, unknown>;
+}): Promise<NotionPage> {
+  const parent = options.parentType === "database"
+    ? { database_id: options.parentId }
+    : { page_id: options.parentId };
+
+  const properties: Record<string, unknown> = options.properties || {};
+
+  // Set title based on parent type
+  if (options.parentType === "database") {
+    // For database pages, title goes in the title property
+    properties.title = properties.title || {
+      title: [{ text: { content: options.title } }],
+    };
+  }
+
+  const children: Array<Record<string, unknown>> = [];
+
+  // Add title as heading for page children
+  if (options.parentType === "page") {
+    children.push({
+      object: "block",
+      type: "heading_1",
+      heading_1: {
+        rich_text: [{ type: "text", text: { content: options.title } }],
+      },
+    });
+  }
+
+  // Add content as paragraph blocks
+  if (options.content) {
+    const paragraphs = options.content.split("\n\n");
+    for (const paragraph of paragraphs) {
+      if (paragraph.trim()) {
+        children.push({
+          object: "block",
+          type: "paragraph",
+          paragraph: {
+            rich_text: [{ type: "text", text: { content: paragraph.trim() } }],
+          },
+        });
+      }
+    }
+  }
+
+  return notionFetch<NotionPage>("/pages", {
+    method: "POST",
+    body: JSON.stringify({
+      parent,
+      properties,
+      children: children.length > 0 ? children : undefined,
+    }),
+  });
+}
+
+// Helper to extract plain text from Notion rich text
+export function extractPlainText(blocks: NotionBlock[]): string {
+  const texts: string[] = [];
+
+  for (const block of blocks) {
+    const blockType = block.type;
+    const blockContent = block[blockType] as { rich_text?: Array<{ plain_text: string }> };
+
+    if (blockContent?.rich_text) {
+      const text = blockContent.rich_text.map((t) => t.plain_text).join("");
+      if (text) texts.push(text);
+    }
+  }
+
+  return texts.join("\n\n");
+}
+
+// Helper to get page title
+export function getPageTitle(page: NotionPage): string {
+  for (const prop of Object.values(page.properties)) {
+    if (prop.type === "title" && prop.title) {
+      return prop.title.map((t) => t.plain_text).join("");
+    }
+  }
+  return "Untitled";
+}

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

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

package/dist/integrations/onedrive/connector.json

@@ -0,0 +1,100 @@
+{
+  "name": "onedrive",
+  "displayName": "OneDrive",
+  "icon": "onedrive.svg",
+  "description": "Access and manage files in Microsoft OneDrive",
+  "auth": {
+    "type": "oauth2",
+    "provider": "microsoft",
+    "authorizationUrl": "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+    "tokenUrl": "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+    "scopes": [
+      "Files.Read",
+      "Files.ReadWrite",
+      "Files.Read.All",
+      "Files.ReadWrite.All",
+      "offline_access"
+    ],
+    "callbackPath": "/api/auth/onedrive/callback",
+    "tokenAuthMethod": "body",
+    "requiredApis": [
+      {
+        "name": "Microsoft Graph API",
+        "enableUrl": "https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "MICROSOFT_CLIENT_ID",
+      "description": "Microsoft Azure App Client ID (shared with Outlook/Teams/SharePoint)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade"
+    },
+    {
+      "name": "MICROSOFT_CLIENT_SECRET",
+      "description": "Microsoft Azure App Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-files",
+      "name": "List Files",
+      "description": "List files and folders in a OneDrive folder",
+      "requiresWrite": false
+    },
+    {
+      "id": "search-files",
+      "name": "Search Files",
+      "description": "Search for files and folders in OneDrive by name or content",
+      "requiresWrite": false
+    },
+    {
+      "id": "upload-file",
+      "name": "Upload File",
+      "description": "Upload or update a file in OneDrive",
+      "requiresWrite": true
+    },
+    {
+      "id": "download-file",
+      "name": "Download File",
+      "description": "Download file content from OneDrive",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "search-documents",
+      "title": "Search documents",
+      "prompt": "Search for documents in OneDrive and summarize their content.",
+      "category": "productivity",
+      "icon": "search"
+    },
+    {
+      "id": "list-recent-files",
+      "title": "List recent files",
+      "prompt": "Show me the most recently modified files in my OneDrive.",
+      "category": "productivity",
+      "icon": "document"
+    },
+    {
+      "id": "organize-files",
+      "title": "Organize files",
+      "prompt": "Help me organize and manage files in my OneDrive storage.",
+      "category": "productivity",
+      "icon": "folder"
+    },
+    {
+      "id": "backup-file",
+      "title": "Backup a file",
+      "prompt": "Upload and backup a file to my OneDrive storage.",
+      "category": "productivity",
+      "icon": "upload"
+    }
+  ],
+  "suggestedWith": ["outlook", "teams", "sharepoint"]
+}

package/dist/integrations/onedrive/files/_env.example

@@ -0,0 +1,23 @@
+# OneDrive Integration Environment Variables
+
+# Microsoft Azure App Client ID
+# Get this from https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade
+MICROSOFT_CLIENT_ID=your_client_id_here
+
+# Microsoft Azure App Client Secret
+# Get this from https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade
+MICROSOFT_CLIENT_SECRET=your_client_secret_here
+
+# Setup Instructions:
+# 1. Go to https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade
+# 2. Create a new app registration or select an existing one
+# 3. Note the Application (client) ID
+# 4. Create a new client secret under "Certificates & secrets"
+# 5. Add the OAuth2 redirect URI under "Authentication": http://localhost:3000/api/auth/onedrive/callback
+# 6. Grant the following Microsoft Graph API permissions under "API permissions":
+#    - Files.Read
+#    - Files.ReadWrite
+#    - Files.Read.All
+#    - Files.ReadWrite.All
+#    - offline_access
+# 7. Grant admin consent if required by your organization

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

@@ -0,0 +1,38 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { downloadFile, formatFileSize } from "../../lib/onedrive-client.ts";
+
+export default tool({
+  id: "download-file",
+  description: "Download file content from OneDrive. Returns the file content and metadata.",
+  inputSchema: z.object({
+    itemId: z.string().describe("The ID of the file to download"),
+    preview: z.boolean().default(false).describe(
+      "If true, return only first 1000 characters as preview",
+    ),
+  }),
+  async execute({ itemId, preview }) {
+    const { content, metadata } = await downloadFile(itemId);
+
+    const displayContent = preview ? content.substring(0, 1000) : content;
+    const isTruncated = preview && content.length > 1000;
+
+    return {
+      content: displayContent,
+      isTruncated,
+      metadata: {
+        id: metadata.id,
+        name: metadata.name,
+        size: metadata.size,
+        sizeFormatted: formatFileSize(metadata.size),
+        mimeType: metadata.mimeType,
+        createdDateTime: metadata.createdDateTime,
+        lastModifiedDateTime: metadata.lastModifiedDateTime,
+        webUrl: metadata.webUrl,
+      },
+      message: isTruncated
+        ? `Retrieved preview (first 1000 characters) of ${metadata.name}`
+        : `Retrieved full content of ${metadata.name}`,
+    };
+  },
+});