veryfront 0.0.49 → 0.0.50

package/dist/integrations/sentry/files/ai/tools/list-issues.ts

@@ -0,0 +1,57 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listIssues } from "../../lib/sentry-client.ts";
+
+export default tool({
+  id: "list-issues",
+  description:
+    "List issues/errors in a Sentry project with optional filters. Returns issue details including title, status, error count, and last seen date.",
+  inputSchema: z.object({
+    projectSlug: z.string().describe("The slug of the project to list issues from"),
+    query: z.string().optional().describe("Search query to filter issues (e.g., 'is:unresolved')"),
+    status: z.enum(["resolved", "unresolved", "ignored"]).optional().describe(
+      "Filter by issue status",
+    ),
+    sort: z.enum(["date", "new", "freq", "priority", "user"]).optional().describe(
+      "Sort order: date (most recent), new (newest), freq (most frequent), priority, user (most users affected)",
+    ),
+    limit: z.number().min(1).max(100).default(25).describe(
+      "Maximum number of issues to return (1-100)",
+    ),
+  }),
+  async execute({ projectSlug, query, status, sort, limit }) {
+    const issues = await listIssues(projectSlug, {
+      query,
+      status,
+      sort,
+      limit,
+    });
+
+    return issues.map((issue) => ({
+      id: issue.id,
+      shortId: issue.shortId,
+      title: issue.title,
+      culprit: issue.culprit,
+      permalink: issue.permalink,
+      level: issue.level,
+      status: issue.status,
+      substatus: issue.substatus,
+      platform: issue.platform,
+      project: {
+        id: issue.project.id,
+        name: issue.project.name,
+        slug: issue.project.slug,
+      },
+      type: issue.type,
+      metadata: issue.metadata,
+      count: issue.count,
+      userCount: issue.userCount,
+      firstSeen: issue.firstSeen,
+      lastSeen: issue.lastSeen,
+      numComments: issue.numComments,
+      isBookmarked: issue.isBookmarked,
+      isSubscribed: issue.isSubscribed,
+      assignedTo: issue.assignedTo,
+    }));
+  },
+});

package/dist/integrations/sentry/files/ai/tools/list-projects.ts

@@ -0,0 +1,32 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listProjects } from "../../lib/sentry-client.ts";
+
+export default tool({
+  id: "list-projects",
+  description:
+    "List all projects in your Sentry organization. Returns project details including name, platform, status, and team information.",
+  inputSchema: z.object({}),
+  async execute() {
+    const projects = await listProjects();
+
+    return projects.map((project) => ({
+      id: project.id,
+      slug: project.slug,
+      name: project.name,
+      platform: project.platform,
+      status: project.status,
+      dateCreated: project.dateCreated,
+      firstEvent: project.firstEvent,
+      isBookmarked: project.isBookmarked,
+      isMember: project.isMember,
+      hasAccess: project.hasAccess,
+      teams: project.teams.map((team) => ({
+        id: team.id,
+        name: team.name,
+        slug: team.slug,
+      })),
+      features: project.features,
+    }));
+  },
+});

package/dist/integrations/sentry/files/ai/tools/resolve-issue.ts

@@ -0,0 +1,28 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { resolveIssue } from "../../lib/sentry-client.ts";
+
+export default tool({
+  id: "resolve-issue",
+  description:
+    "Mark a Sentry issue as resolved. Use this after you've fixed a bug or determined an issue is no longer relevant.",
+  inputSchema: z.object({
+    issueId: z.string().describe("The ID of the issue to resolve"),
+  }),
+  async execute({ issueId }) {
+    const issue = await resolveIssue(issueId);
+
+    return {
+      success: true,
+      issue: {
+        id: issue.id,
+        shortId: issue.shortId,
+        title: issue.title,
+        status: issue.status,
+        statusDetails: issue.statusDetails,
+        permalink: issue.permalink,
+      },
+      message: `Issue ${issue.shortId} has been marked as resolved.`,
+    };
+  },
+});

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

@@ -0,0 +1,268 @@
+import { getApiKey, getOrg } from "./token-store.ts";
+
+const SENTRY_API_BASE_URL = "https://sentry.io/api/0";
+
+// Sentry API Types
+
+export interface Organization {
+  id: string;
+  slug: string;
+  name: string;
+  dateCreated: string;
+  status: {
+    id: string;
+    name: string;
+  };
+  avatar?: {
+    avatarType: string;
+    avatarUuid: string | null;
+  };
+  features: string[];
+}
+
+export interface Project {
+  id: string;
+  slug: string;
+  name: string;
+  platform?: string;
+  dateCreated: string;
+  isBookmarked: boolean;
+  isMember: boolean;
+  features: string[];
+  firstEvent: string | null;
+  firstTransactionEvent: boolean;
+  access: string[];
+  hasAccess: boolean;
+  hasCustomMetrics: boolean;
+  hasMinifiedStackTrace: boolean;
+  hasMonitors: boolean;
+  hasProfiles: boolean;
+  hasReplays: boolean;
+  hasSessions: boolean;
+  team?: {
+    id: string;
+    name: string;
+    slug: string;
+  };
+  teams: Array<{
+    id: string;
+    name: string;
+    slug: string;
+  }>;
+  eventProcessing: {
+    symbolicationDegraded: boolean;
+  };
+  status: string;
+}
+
+export interface Issue {
+  id: string;
+  shareId: string | null;
+  shortId: string;
+  title: string;
+  culprit: string;
+  permalink: string;
+  logger: string | null;
+  level: string;
+  status: string;
+  statusDetails: Record<string, unknown>;
+  substatus: string | null;
+  isPublic: boolean;
+  platform: string;
+  project: {
+    id: string;
+    name: string;
+    slug: string;
+    platform: string;
+  };
+  type: string;
+  metadata: {
+    value?: string;
+    type?: string;
+    filename?: string;
+    function?: string;
+    title?: string;
+  };
+  numComments: number;
+  assignedTo: {
+    id: string;
+    name: string;
+    type: string;
+  } | null;
+  isBookmarked: boolean;
+  isSubscribed: boolean;
+  subscriptionDetails: {
+    reason?: string;
+  } | null;
+  hasSeen: boolean;
+  annotations: string[];
+  isUnhandled: boolean;
+  count: string;
+  userCount: number;
+  firstSeen: string;
+  lastSeen: string;
+  stats?: {
+    "24h": Array<[number, number]>;
+  };
+}
+
+export interface Event {
+  id: string;
+  groupID: string;
+  eventID: string;
+  projectID: string;
+  size: number;
+  platform: string;
+  message: string;
+  dateCreated: string;
+  dateReceived: string;
+  user: {
+    id?: string;
+    email?: string;
+    username?: string;
+    ip_address?: string;
+  } | null;
+  entries: Array<{
+    type: string;
+    data: unknown;
+  }>;
+  contexts: Record<string, unknown>;
+  tags: Array<{
+    key: string;
+    value: string;
+  }>;
+  errors: Array<{
+    type: string;
+    message: string;
+  }>;
+}
+
+async function sentryFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const authToken = getApiKey() || process.env.SENTRY_AUTH_TOKEN;
+  if (!authToken) {
+    throw new Error("Not authenticated with Sentry. Please set SENTRY_AUTH_TOKEN.");
+  }
+
+  const response = await fetch(`${SENTRY_API_BASE_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${authToken}`,
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    const errorMessage = (error as { detail?: string }).detail ||
+      `Sentry API error: ${response.status} ${response.statusText}`;
+    throw new Error(errorMessage);
+  }
+
+  return response.json();
+}
+
+/**
+ * List all organizations for the authenticated user
+ */
+export function listOrganizations(): Promise<Organization[]> {
+  return sentryFetch<Organization[]>("/organizations/");
+}
+
+/**
+ * List all projects in the configured organization
+ */
+export function listProjects(): Promise<Project[]> {
+  const org = getOrg();
+  if (!org) {
+    throw new Error(
+      "Sentry organization not configured. Please set SENTRY_ORG environment variable.",
+    );
+  }
+
+  return sentryFetch<Project[]>(`/organizations/${org}/projects/`);
+}
+
+/**
+ * Get details for a specific project
+ */
+export function getProject(projectSlug: string): Promise<Project> {
+  const org = getOrg();
+  if (!org) {
+    throw new Error(
+      "Sentry organization not configured. Please set SENTRY_ORG environment variable.",
+    );
+  }
+
+  return sentryFetch<Project>(`/projects/${org}/${projectSlug}/`);
+}
+
+/**
+ * List issues in a project with optional filters
+ */
+export function listIssues(
+  projectSlug: string,
+  options: {
+    query?: string;
+    status?: "resolved" | "unresolved" | "ignored";
+    sort?: "date" | "new" | "freq" | "priority" | "user";
+    limit?: number;
+  } = {},
+): Promise<Issue[]> {
+  const org = getOrg();
+  if (!org) {
+    throw new Error(
+      "Sentry organization not configured. Please set SENTRY_ORG environment variable.",
+    );
+  }
+
+  const params = new URLSearchParams();
+  params.append("project", projectSlug);
+
+  if (options.query) {
+    params.append("query", options.query);
+  }
+  if (options.status) {
+    params.append("query", `is:${options.status}`);
+  }
+  if (options.sort) {
+    params.append("sort", options.sort);
+  }
+  if (options.limit) {
+    params.append("limit", options.limit.toString());
+  }
+
+  return sentryFetch<Issue[]>(`/organizations/${org}/issues/?${params.toString()}`);
+}
+
+/**
+ * Get detailed information about a specific issue
+ */
+export function getIssue(issueId: string): Promise<Issue> {
+  return sentryFetch<Issue>(`/issues/${issueId}/`);
+}
+
+/**
+ * Update an issue (e.g., resolve, ignore, assign)
+ */
+export function resolveIssue(issueId: string): Promise<Issue> {
+  return sentryFetch<Issue>(`/issues/${issueId}/`, {
+    method: "PUT",
+    body: JSON.stringify({
+      status: "resolved",
+    }),
+  });
+}
+
+/**
+ * List events for a specific issue
+ */
+export function listEvents(issueId: string, limit: number = 10): Promise<Event[]> {
+  const params = new URLSearchParams();
+  params.append("limit", limit.toString());
+
+  return sentryFetch<Event[]>(`/issues/${issueId}/events/?${params.toString()}`);
+}

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

@@ -0,0 +1,29 @@
+// In-memory token store for development
+// For production, replace with a database-backed implementation
+
+interface TokenData {
+  authToken: string;
+  org: string;
+}
+
+let tokenStore: TokenData | null = null;
+
+export function setApiKey(authToken: string, org: string): void {
+  tokenStore = { authToken, org };
+}
+
+export function getApiKey(): string | null {
+  return tokenStore?.authToken || null;
+}
+
+export function getOrg(): string | null {
+  return tokenStore?.org || process.env.SENTRY_ORG || null;
+}
+
+export function clearTokens(): void {
+  tokenStore = null;
+}
+
+export function isAuthenticated(): boolean {
+  return tokenStore !== null && tokenStore.authToken !== null;
+}

package/dist/integrations/servicenow/connector.json

@@ -0,0 +1,66 @@
+{
+  "name": "servicenow",
+  "displayName": "ServiceNow",
+  "icon": "servicenow.svg",
+  "description": "IT Service Management - incidents, changes, and service requests",
+  "category": "enterprise",
+  "auth": {
+    "type": "oauth2",
+    "provider": "servicenow",
+    "scopes": ["useraccount", "openid"],
+    "callbackPath": "/api/auth/servicenow/callback"
+  },
+  "tools": [
+    {
+      "id": "list-incidents",
+      "name": "List Incidents",
+      "description": "List ServiceNow incidents with optional filters"
+    },
+    {
+      "id": "get-incident",
+      "name": "Get Incident",
+      "description": "Get details of a specific incident"
+    },
+    {
+      "id": "create-incident",
+      "name": "Create Incident",
+      "description": "Create a new incident in ServiceNow"
+    },
+    {
+      "id": "update-incident",
+      "name": "Update Incident",
+      "description": "Update an existing incident"
+    },
+    {
+      "id": "search-knowledge",
+      "name": "Search Knowledge Base",
+      "description": "Search ServiceNow knowledge base articles"
+    }
+  ],
+  "prompts": [
+    {
+      "id": "check-ticket-status",
+      "title": "Check ticket status",
+      "prompt": "Check the status of my recent ServiceNow incidents and summarize any that need attention.",
+      "category": "productivity"
+    },
+    {
+      "id": "create-incident-report",
+      "title": "Create incident",
+      "prompt": "Help me create a new incident in ServiceNow with the appropriate priority and category.",
+      "category": "productivity"
+    },
+    {
+      "id": "search-kb",
+      "title": "Search knowledge base",
+      "prompt": "Search the ServiceNow knowledge base for solutions to common issues.",
+      "category": "research"
+    }
+  ],
+  "envVars": [
+    "SERVICENOW_INSTANCE",
+    "SERVICENOW_CLIENT_ID",
+    "SERVICENOW_CLIENT_SECRET"
+  ],
+  "suggestedWith": ["slack", "jira"]
+}

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

@@ -0,0 +1,5 @@
+# ServiceNow OAuth Configuration
+# Get these from your ServiceNow instance: System OAuth > Application Registry
+SERVICENOW_INSTANCE=your-instance.service-now.com
+SERVICENOW_CLIENT_ID=your_client_id
+SERVICENOW_CLIENT_SECRET=your_client_secret

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

@@ -0,0 +1,58 @@
+/**
+ * Create 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-create-incident",
+  description: "Create a new incident in ServiceNow",
+  inputSchema: z.object({
+    short_description: z.string().describe("Brief description of the incident"),
+    description: z.string().optional().describe("Detailed description of the incident"),
+    urgency: z.enum(["1", "2", "3"]).optional()
+      .describe("Urgency level (1=High, 2=Medium, 3=Low)"),
+    impact: z.enum(["1", "2", "3"]).optional()
+      .describe("Impact level (1=High, 2=Medium, 3=Low)"),
+    category: z.string().optional().describe("Incident category"),
+    subcategory: z.string().optional().describe("Incident subcategory"),
+  }),
+  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 incident = await client.createIncident({
+        short_description: input.short_description,
+        description: input.description,
+        urgency: input.urgency,
+        impact: input.impact,
+        category: input.category,
+        subcategory: input.subcategory,
+      });
+
+      return {
+        success: true,
+        number: incident.number,
+        sys_id: incident.sys_id,
+        short_description: incident.short_description,
+        state: incident.state,
+        priority: incident.priority,
+        message: `Incident ${incident.number} created successfully`,
+      };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : "Failed to create incident",
+      };
+    }
+  },
+});

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

@@ -0,0 +1,59 @@
+/**
+ * Get 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-get-incident",
+  description:
+    "Get details of a specific ServiceNow incident by number (e.g., INC0010001) or sys_id",
+  inputSchema: z.object({
+    id: z.string().describe("Incident number (INC0010001) or sys_id"),
+  }),
+  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 incident = await client.getIncident(input.id);
+
+      return {
+        number: incident.number,
+        sys_id: incident.sys_id,
+        short_description: incident.short_description,
+        description: incident.description,
+        state: incident.state,
+        priority: incident.priority,
+        urgency: incident.urgency,
+        impact: incident.impact,
+        category: incident.category,
+        subcategory: incident.subcategory,
+        assigned_to: typeof incident.assigned_to === "object"
+          ? incident.assigned_to.display_value
+          : incident.assigned_to,
+        caller_id: typeof incident.caller_id === "object"
+          ? incident.caller_id.display_value
+          : incident.caller_id,
+        opened_at: incident.opened_at,
+        resolved_at: incident.resolved_at,
+        closed_at: incident.closed_at,
+        created: incident.sys_created_on,
+        updated: incident.sys_updated_on,
+      };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : "Failed to get incident",
+      };
+    }
+  },
+});

package/dist/integrations/servicenow/files/ai/tools/list-incidents.ts

@@ -0,0 +1,72 @@
+/**
+ * List ServiceNow Incidents 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-list-incidents",
+  description:
+    "List incidents from ServiceNow with optional filters for state, priority, or search query",
+  inputSchema: z.object({
+    limit: z.number().optional().describe("Maximum number of incidents to return (default: 20)"),
+    state: z.enum(["new", "in_progress", "on_hold", "resolved", "closed"]).optional()
+      .describe("Filter by incident state"),
+    priority: z.enum(["1", "2", "3", "4", "5"]).optional()
+      .describe("Filter by priority (1=Critical, 2=High, 3=Moderate, 4=Low, 5=Planning)"),
+    query: z.string().optional().describe("Search query for incident short description"),
+  }),
+  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();
+
+      // Map state names to ServiceNow state values
+      const stateMap: Record<string, string> = {
+        new: "1",
+        in_progress: "2",
+        on_hold: "3",
+        resolved: "6",
+        closed: "7",
+      };
+
+      const incidents = await client.listIncidents({
+        limit: input.limit,
+        state: input.state ? stateMap[input.state] : undefined,
+        priority: input.priority,
+        query: input.query,
+      });
+
+      return {
+        count: incidents.length,
+        incidents: incidents.map((inc) => ({
+          number: inc.number,
+          short_description: inc.short_description,
+          state: inc.state,
+          priority: inc.priority,
+          urgency: inc.urgency,
+          impact: inc.impact,
+          assigned_to: typeof inc.assigned_to === "object"
+            ? inc.assigned_to.display_value
+            : inc.assigned_to,
+          opened_at: inc.opened_at,
+          sys_id: inc.sys_id,
+        })),
+      };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : "Failed to list incidents",
+      };
+    }
+  },
+});