veryfront 0.0.49 → 0.0.51

package/dist/integrations/servicenow/files/ai/tools/update-incident.ts

@@ -0,0 +1,60 @@
+/**
+ * Update ServiceNow Incident Tool
+ */
+
+import { z } from "zod";
+import { defineTool } from "veryfront/ai";
+import { getServiceNowClient } from "../../lib/servicenow-client.ts";
+import { isServiceNowConnected } from "../../lib/token-store.ts";
+
+export default defineTool({
+  id: "servicenow-update-incident",
+  description: "Update an existing incident in ServiceNow",
+  inputSchema: z.object({
+    sys_id: z.string().describe("The sys_id of the incident to update"),
+    state: z.enum(["1", "2", "3", "6", "7"]).optional()
+      .describe("New state (1=New, 2=In Progress, 3=On Hold, 6=Resolved, 7=Closed)"),
+    short_description: z.string().optional().describe("Updated short description"),
+    description: z.string().optional().describe("Updated description"),
+    urgency: z.enum(["1", "2", "3"]).optional()
+      .describe("Updated urgency (1=High, 2=Medium, 3=Low)"),
+    impact: z.enum(["1", "2", "3"]).optional()
+      .describe("Updated impact (1=High, 2=Medium, 3=Low)"),
+    work_notes: z.string().optional().describe("Add work notes to the incident"),
+    close_notes: z.string().optional().describe("Close notes (required when closing)"),
+  }),
+  async execute(input) {
+    const connected = await isServiceNowConnected();
+    if (!connected) {
+      return {
+        error: "ServiceNow not connected",
+        action: "Please connect ServiceNow via /api/auth/servicenow",
+      };
+    }
+
+    try {
+      const client = getServiceNowClient();
+      const { sys_id, ...updateData } = input;
+
+      // Filter out undefined values
+      const cleanData = Object.fromEntries(
+        Object.entries(updateData).filter(([_, v]) => v !== undefined),
+      );
+
+      const incident = await client.updateIncident(sys_id, cleanData);
+
+      return {
+        success: true,
+        number: incident.number,
+        sys_id: incident.sys_id,
+        state: incident.state,
+        updated: incident.sys_updated_on,
+        message: `Incident ${incident.number} updated successfully`,
+      };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : "Failed to update incident",
+      };
+    }
+  },
+});

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

@@ -0,0 +1,89 @@
+/**
+ * ServiceNow OAuth Callback Route
+ *
+ * Handles the OAuth callback and exchanges the code for tokens.
+ */
+
+import { setServiceNowTokens } from "../../../../../lib/token-store.ts";
+
+const getEnv = (name: string): string | undefined => {
+  if (typeof Deno !== "undefined") {
+    // @ts-ignore: Deno global
+    return Deno.env.get(name);
+  }
+  // @ts-ignore: Node process
+  return globalThis.process?.env?.[name];
+};
+
+export async function GET(request: Request): Promise<Response> {
+  const url = new URL(request.url);
+  const code = url.searchParams.get("code");
+  const error = url.searchParams.get("error");
+  const errorDescription = url.searchParams.get("error_description");
+
+  const baseUrl = getEnv("NEXT_PUBLIC_APP_URL") || `${url.protocol}//${url.host}`;
+
+  if (error) {
+    console.error("ServiceNow OAuth error:", error, errorDescription);
+    return Response.redirect(
+      `${baseUrl}/?error=servicenow_oauth_failed&description=${
+        encodeURIComponent(errorDescription || error)
+      }`,
+      302,
+    );
+  }
+
+  if (!code) {
+    return Response.redirect(`${baseUrl}/?error=no_code`, 302);
+  }
+
+  const instance = getEnv("SERVICENOW_INSTANCE");
+  const clientId = getEnv("SERVICENOW_CLIENT_ID");
+  const clientSecret = getEnv("SERVICENOW_CLIENT_SECRET");
+
+  if (!instance || !clientId || !clientSecret) {
+    return Response.redirect(`${baseUrl}/?error=servicenow_not_configured`, 302);
+  }
+
+  const instanceUrl = instance.includes("://") ? instance : `https://${instance}`;
+
+  const redirectUri = `${baseUrl}/api/auth/servicenow/callback`;
+
+  try {
+    // Exchange code for tokens
+    const tokenResponse = await fetch(`${instanceUrl}/oauth_token.do`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+      body: new URLSearchParams({
+        grant_type: "authorization_code",
+        code,
+        redirect_uri: redirectUri,
+        client_id: clientId,
+        client_secret: clientSecret,
+      }),
+    });
+
+    if (!tokenResponse.ok) {
+      const errorText = await tokenResponse.text();
+      console.error("ServiceNow token exchange failed:", errorText);
+      return Response.redirect(`${baseUrl}/?error=token_exchange_failed`, 302);
+    }
+
+    const tokens = await tokenResponse.json();
+
+    // Store tokens
+    await setServiceNowTokens({
+      accessToken: tokens.access_token,
+      refreshToken: tokens.refresh_token,
+      expiresAt: tokens.expires_in ? Date.now() + tokens.expires_in * 1000 : undefined,
+      instanceUrl,
+    });
+
+    return Response.redirect(`${baseUrl}/?connected=servicenow`, 302);
+  } catch (err) {
+    console.error("ServiceNow OAuth error:", err);
+    return Response.redirect(`${baseUrl}/?error=servicenow_oauth_failed`, 302);
+  }
+}

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

@@ -0,0 +1,42 @@
+/**
+ * ServiceNow OAuth Init Route
+ *
+ * Redirects to ServiceNow OAuth authorization page.
+ */
+
+const getEnv = (name: string): string | undefined => {
+  if (typeof Deno !== "undefined") {
+    // @ts-ignore: Deno global
+    return Deno.env.get(name);
+  }
+  // @ts-ignore: Node process
+  return globalThis.process?.env?.[name];
+};
+
+export function GET(request: Request): Response {
+  const instance = getEnv("SERVICENOW_INSTANCE");
+  const clientId = getEnv("SERVICENOW_CLIENT_ID");
+
+  if (!instance || !clientId) {
+    return Response.json(
+      { error: "ServiceNow OAuth not configured" },
+      { status: 500 },
+    );
+  }
+
+  const instanceUrl = instance.includes("://") ? instance : `https://${instance}`;
+
+  const url = new URL(request.url);
+  const baseUrl = getEnv("NEXT_PUBLIC_APP_URL") || `${url.protocol}//${url.host}`;
+  const redirectUri = `${baseUrl}/api/auth/servicenow/callback`;
+
+  const state = crypto.randomUUID();
+
+  const authUrl = new URL(`${instanceUrl}/oauth_auth.do`);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", clientId);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("state", state);
+
+  return Response.redirect(authUrl.toString(), 302);
+}

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

@@ -0,0 +1,239 @@
+/**
+ * ServiceNow API Client
+ *
+ * Handles authentication and API calls to ServiceNow REST API.
+ */
+
+import { getServiceNowTokens } from "./token-store.ts";
+
+const getEnv = (name: string): string | undefined => {
+  if (typeof Deno !== "undefined") {
+    // @ts-ignore: Deno global
+    return Deno.env.get(name);
+  }
+  // @ts-ignore: Node process
+  return globalThis.process?.env?.[name];
+};
+
+export interface ServiceNowIncident {
+  sys_id: string;
+  number: string;
+  short_description: string;
+  description: string;
+  state: string;
+  priority: string;
+  urgency: string;
+  impact: string;
+  category: string;
+  subcategory: string;
+  assigned_to: { display_value: string; link: string } | string;
+  caller_id: { display_value: string; link: string } | string;
+  opened_at: string;
+  resolved_at: string | null;
+  closed_at: string | null;
+  sys_created_on: string;
+  sys_updated_on: string;
+}
+
+export interface ServiceNowKnowledgeArticle {
+  sys_id: string;
+  number: string;
+  short_description: string;
+  text: string;
+  kb_category: string;
+  published: string;
+  sys_created_on: string;
+}
+
+export interface ServiceNowResponse<T> {
+  result: T;
+}
+
+export interface ServiceNowListResponse<T> {
+  result: T[];
+}
+
+export class ServiceNowClient {
+  private instance: string;
+  private accessToken: string | null = null;
+
+  constructor() {
+    const instance = getEnv("SERVICENOW_INSTANCE");
+    if (!instance) {
+      throw new Error("SERVICENOW_INSTANCE not configured");
+    }
+    this.instance = instance.replace(/^https?:\/\//, "").replace(/\/$/, "");
+  }
+
+  private get baseUrl(): string {
+    return `https://${this.instance}/api/now`;
+  }
+
+  async ensureAuthenticated(): Promise<void> {
+    const tokens = await getServiceNowTokens();
+    if (!tokens) {
+      throw new Error(
+        "ServiceNow not connected. Please connect via /api/auth/servicenow",
+      );
+    }
+    this.accessToken = tokens.accessToken;
+  }
+
+  private async request<T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    await this.ensureAuthenticated();
+
+    const url = `${this.baseUrl}${endpoint}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`ServiceNow API error: ${response.status} ${errorText}`);
+    }
+
+    return response.json();
+  }
+
+  /**
+   * List incidents with optional filters
+   */
+  async listIncidents(options: {
+    limit?: number;
+    offset?: number;
+    state?: string;
+    priority?: string;
+    assignedTo?: string;
+    query?: string;
+  } = {}): Promise<ServiceNowIncident[]> {
+    const params = new URLSearchParams();
+    params.set("sysparm_limit", String(options.limit || 20));
+    params.set("sysparm_offset", String(options.offset || 0));
+    params.set("sysparm_display_value", "all");
+
+    const queryParts: string[] = [];
+    if (options.state) queryParts.push(`state=${options.state}`);
+    if (options.priority) queryParts.push(`priority=${options.priority}`);
+    if (options.assignedTo) queryParts.push(`assigned_to.name=${options.assignedTo}`);
+    if (options.query) queryParts.push(`short_descriptionLIKE${options.query}`);
+
+    if (queryParts.length > 0) {
+      params.set("sysparm_query", queryParts.join("^"));
+    }
+
+    const response = await this.request<ServiceNowListResponse<ServiceNowIncident>>(
+      `/table/incident?${params}`,
+    );
+    return response.result;
+  }
+
+  /**
+   * Get a specific incident by sys_id or number
+   */
+  async getIncident(idOrNumber: string): Promise<ServiceNowIncident> {
+    // Check if it's a number (INC0010001) or sys_id
+    const isNumber = idOrNumber.toUpperCase().startsWith("INC");
+    const params = new URLSearchParams();
+    params.set("sysparm_display_value", "all");
+
+    if (isNumber) {
+      params.set("sysparm_query", `number=${idOrNumber}`);
+      const response = await this.request<ServiceNowListResponse<ServiceNowIncident>>(
+        `/table/incident?${params}`,
+      );
+      if (response.result.length === 0) {
+        throw new Error(`Incident ${idOrNumber} not found`);
+      }
+      return response.result[0];
+    }
+
+    const response = await this.request<ServiceNowResponse<ServiceNowIncident>>(
+      `/table/incident/${idOrNumber}?${params}`,
+    );
+    return response.result;
+  }
+
+  /**
+   * Create a new incident
+   */
+  async createIncident(data: {
+    short_description: string;
+    description?: string;
+    urgency?: string;
+    impact?: string;
+    category?: string;
+    subcategory?: string;
+    caller_id?: string;
+  }): Promise<ServiceNowIncident> {
+    const response = await this.request<ServiceNowResponse<ServiceNowIncident>>(
+      "/table/incident",
+      {
+        method: "POST",
+        body: JSON.stringify(data),
+      },
+    );
+    return response.result;
+  }
+
+  /**
+   * Update an existing incident
+   */
+  async updateIncident(
+    sysId: string,
+    data: Partial<{
+      short_description: string;
+      description: string;
+      state: string;
+      urgency: string;
+      impact: string;
+      assigned_to: string;
+      work_notes: string;
+      close_notes: string;
+    }>,
+  ): Promise<ServiceNowIncident> {
+    const response = await this.request<ServiceNowResponse<ServiceNowIncident>>(
+      `/table/incident/${sysId}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(data),
+      },
+    );
+    return response.result;
+  }
+
+  /**
+   * Search knowledge base articles
+   */
+  async searchKnowledge(query: string, limit = 10): Promise<ServiceNowKnowledgeArticle[]> {
+    const params = new URLSearchParams();
+    params.set("sysparm_limit", String(limit));
+    params.set(
+      "sysparm_query",
+      `short_descriptionLIKE${query}^ORtextLIKE${query}^workflow_state=published`,
+    );
+
+    const response = await this.request<ServiceNowListResponse<ServiceNowKnowledgeArticle>>(
+      `/table/kb_knowledge?${params}`,
+    );
+    return response.result;
+  }
+}
+
+// Singleton instance
+let client: ServiceNowClient | null = null;
+
+export function getServiceNowClient(): ServiceNowClient {
+  if (!client) {
+    client = new ServiceNowClient();
+  }
+  return client;
+}

package/dist/integrations/sharepoint/connector.json

@@ -0,0 +1,99 @@
+{
+  "name": "sharepoint",
+  "displayName": "SharePoint",
+  "icon": "sharepoint.svg",
+  "description": "Access and manage SharePoint sites, document libraries, and files",
+  "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": [
+      "Sites.Read.All",
+      "Sites.ReadWrite.All",
+      "Files.Read.All",
+      "Files.ReadWrite.All",
+      "offline_access"
+    ],
+    "callbackPath": "/api/auth/sharepoint/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)",
+      "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-sites",
+      "name": "List SharePoint Sites",
+      "description": "List all SharePoint sites the user has access to",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-site",
+      "name": "Get Site Details",
+      "description": "Get detailed information about a specific SharePoint site",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-files",
+      "name": "List Files",
+      "description": "List files and folders in a SharePoint document library",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-file",
+      "name": "Get File",
+      "description": "Get file metadata and content from SharePoint",
+      "requiresWrite": false
+    },
+    {
+      "id": "upload-file",
+      "name": "Upload File",
+      "description": "Upload a file to a SharePoint document library",
+      "requiresWrite": true
+    }
+  ],
+  "prompts": [
+    {
+      "id": "search-documents",
+      "title": "Search documents",
+      "prompt": "Search for documents in SharePoint sites and summarize their content.",
+      "category": "productivity",
+      "icon": "search"
+    },
+    {
+      "id": "list-recent-files",
+      "title": "List recent files",
+      "prompt": "Show me the most recently modified files across all SharePoint sites I have access to.",
+      "category": "productivity",
+      "icon": "document"
+    },
+    {
+      "id": "organize-documents",
+      "title": "Organize documents",
+      "prompt": "Help me organize and categorize documents in a SharePoint library.",
+      "category": "productivity",
+      "icon": "folder"
+    }
+  ],
+  "suggestedWith": ["outlook", "teams", "onedrive"]
+}

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