veryfront 0.0.49 → 0.0.50

package/dist/integrations/servicenow/files/ai/tools/search-knowledge.ts

@@ -0,0 +1,48 @@
+/**
+ * Search ServiceNow Knowledge Base 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-search-knowledge",
+  description: "Search the ServiceNow knowledge base for articles matching a query",
+  inputSchema: z.object({
+    query: z.string().describe("Search query for knowledge articles"),
+    limit: z.number().optional().describe("Maximum number of articles to return (default: 10)"),
+  }),
+  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 articles = await client.searchKnowledge(input.query, input.limit || 10);
+
+      return {
+        count: articles.length,
+        articles: articles.map((article) => ({
+          number: article.number,
+          title: article.short_description,
+          category: article.kb_category,
+          published: article.published,
+          sys_id: article.sys_id,
+          // Truncate text for summary
+          summary: article.text?.substring(0, 500) + (article.text?.length > 500 ? "..." : ""),
+        })),
+      };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : "Failed to search knowledge base",
+      };
+    }
+  },
+});

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/servicenow/files/lib/token-store.ts

@@ -0,0 +1,42 @@
+/**
+ * ServiceNow Token Store
+ *
+ * Simple in-memory token storage for development.
+ * In production, use a persistent store like Redis or a database.
+ */
+
+export interface ServiceNowTokens {
+  accessToken: string;
+  refreshToken?: string;
+  expiresAt?: number;
+  instanceUrl?: string;
+}
+
+// In-memory storage (replace with persistent storage in production)
+let tokens: ServiceNowTokens | null = null;
+
+export function getServiceNowTokens(): Promise<ServiceNowTokens | null> {
+  return Promise.resolve(tokens);
+}
+
+export function setServiceNowTokens(newTokens: ServiceNowTokens): Promise<void> {
+  tokens = newTokens;
+  return Promise.resolve();
+}
+
+export function clearServiceNowTokens(): Promise<void> {
+  tokens = null;
+  return Promise.resolve();
+}
+
+export async function isServiceNowConnected(): Promise<boolean> {
+  const t = await getServiceNowTokens();
+  if (!t) return false;
+
+  // Check if token is expired (with 5 minute buffer)
+  if (t.expiresAt && Date.now() > t.expiresAt - 5 * 60 * 1000) {
+    return false;
+  }
+
+  return true;
+}

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"]
+}