veryfront 0.0.48 → 0.0.50

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

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

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

@@ -0,0 +1,7 @@
+/**
+ * Intercom OAuth Init
+ */
+
+import { intercomConfig, createOAuthInitHandler } from "veryfront/oauth";
+
+export const GET = createOAuthInitHandler(intercomConfig);

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

@@ -0,0 +1,308 @@
+import { getAccessToken } from "./token-store.ts";
+
+const INTERCOM_BASE_URL = "https://api.intercom.io";
+
+interface IntercomResponse<T> {
+  type: string;
+  data?: T;
+  pages?: {
+    next?: string | null;
+    page: number;
+    per_page: number;
+    total_pages: number;
+  };
+}
+
+interface IntercomContact {
+  type: "contact";
+  id: string;
+  external_id?: string;
+  email?: string;
+  phone?: string;
+  name?: string;
+  avatar?: string;
+  role?: string;
+  created_at: number;
+  updated_at: number;
+  signed_up_at?: number;
+  last_seen_at?: number;
+  owner_id?: number;
+  custom_attributes?: Record<string, unknown>;
+  tags?: Array<{ id: string; name: string }>;
+}
+
+interface IntercomConversation {
+  type: "conversation";
+  id: string;
+  created_at: number;
+  updated_at: number;
+  source: {
+    type: string;
+    id: string;
+    delivered_as: string;
+    subject?: string;
+    body?: string;
+    author: {
+      type: string;
+      id: string;
+      name?: string;
+      email?: string;
+    };
+  };
+  contacts?: Array<{
+    type: string;
+    id: string;
+  }>;
+  teammates?: Array<{
+    type: string;
+    id: string;
+  }>;
+  title?: string;
+  state: "open" | "closed" | "snoozed";
+  read: boolean;
+  waiting_since?: number;
+  snoozed_until?: number;
+  priority?: "priority" | "not_priority";
+  conversation_parts?: {
+    type: string;
+    conversation_parts: Array<{
+      type: string;
+      id: string;
+      part_type: string;
+      body: string;
+      created_at: number;
+      updated_at: number;
+      author: {
+        type: string;
+        id: string;
+        name?: string;
+        email?: string;
+      };
+    }>;
+  };
+}
+
+interface IntercomMessageRequest {
+  message_type: "inapp" | "email" | "comment";
+  body: string;
+  from: {
+    type: "admin" | "user" | "contact";
+    id: string;
+  };
+  to?: {
+    type: "user" | "contact";
+    id?: string;
+    email?: string;
+  };
+}
+
+async function intercomFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Intercom. Please connect your account.");
+  }
+
+  const response = await fetch(`${INTERCOM_BASE_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "Intercom-Version": "2.11",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Intercom API error: ${response.status} ${error.errors?.[0]?.message || error.message || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function listContacts(options: {
+  page?: number;
+  perPage?: number;
+} = {}): Promise<{ contacts: IntercomContact[]; hasMore: boolean }> {
+  const params = new URLSearchParams({
+    per_page: String(options.perPage || 50),
+  });
+
+  if (options.page) {
+    params.set("page", String(options.page));
+  }
+
+  const response = await intercomFetch<IntercomResponse<IntercomContact[]>>(
+    `/contacts?${params}`,
+  );
+
+  return {
+    contacts: response.data || [],
+    hasMore: response.pages ? response.pages.page < response.pages.total_pages : false,
+  };
+}
+
+export async function getContact(contactId: string): Promise<IntercomContact> {
+  const response = await intercomFetch<IntercomContact>(
+    `/contacts/${contactId}`,
+  );
+  return response;
+}
+
+export async function searchContacts(query: {
+  email?: string;
+  name?: string;
+}): Promise<IntercomContact[]> {
+  const searchQuery: Record<string, unknown> = {
+    query: {
+      operator: "AND",
+      value: [] as Array<Record<string, unknown>>,
+    },
+  };
+
+  if (query.email) {
+    (searchQuery.query as { value: Array<Record<string, unknown>> }).value.push({
+      field: "email",
+      operator: "=",
+      value: query.email,
+    });
+  }
+
+  if (query.name) {
+    (searchQuery.query as { value: Array<Record<string, unknown>> }).value.push({
+      field: "name",
+      operator: "~",
+      value: query.name,
+    });
+  }
+
+  const response = await intercomFetch<IntercomResponse<IntercomContact[]>>(
+    "/contacts/search",
+    {
+      method: "POST",
+      body: JSON.stringify(searchQuery),
+    },
+  );
+
+  return response.data || [];
+}
+
+export async function listConversations(options: {
+  page?: number;
+  perPage?: number;
+  open?: boolean;
+} = {}): Promise<{ conversations: IntercomConversation[]; hasMore: boolean }> {
+  const params = new URLSearchParams({
+    per_page: String(options.perPage || 50),
+    display_as: "plaintext",
+  });
+
+  if (options.page) {
+    params.set("page", String(options.page));
+  }
+
+  if (options.open !== undefined) {
+    params.set("state", options.open ? "open" : "closed");
+  }
+
+  const response = await intercomFetch<IntercomResponse<IntercomConversation[]>>(
+    `/conversations?${params}`,
+  );
+
+  return {
+    conversations: response.data || [],
+    hasMore: response.pages ? response.pages.page < response.pages.total_pages : false,
+  };
+}
+
+export async function getConversation(conversationId: string): Promise<IntercomConversation> {
+  const response = await intercomFetch<IntercomConversation>(
+    `/conversations/${conversationId}`,
+  );
+  return response;
+}
+
+export async function sendMessage(options: {
+  conversationId?: string;
+  body: string;
+  messageType?: "comment" | "note";
+  adminId?: string;
+}): Promise<IntercomConversation> {
+  if (options.conversationId) {
+    // Reply to existing conversation
+    const body: Record<string, unknown> = {
+      message_type: options.messageType || "comment",
+      type: "admin",
+      body: options.body,
+    };
+
+    if (options.adminId) {
+      body.admin_id = options.adminId;
+    }
+
+    const response = await intercomFetch<IntercomConversation>(
+      `/conversations/${options.conversationId}/reply`,
+      {
+        method: "POST",
+        body: JSON.stringify(body),
+      },
+    );
+    return response;
+  } else {
+    throw new Error("conversationId is required to send a message");
+  }
+}
+
+export async function createMessage(options: {
+  contactId?: string;
+  email?: string;
+  body: string;
+  messageType: "inapp" | "email";
+  fromId: string;
+}): Promise<{ type: string; id: string }> {
+  const messageBody: IntercomMessageRequest = {
+    message_type: options.messageType,
+    body: options.body,
+    from: {
+      type: "admin",
+      id: options.fromId,
+    },
+  };
+
+  if (options.contactId) {
+    messageBody.to = {
+      type: "contact",
+      id: options.contactId,
+    };
+  } else if (options.email) {
+    messageBody.to = {
+      type: "contact",
+      email: options.email,
+    };
+  } else {
+    throw new Error("Either contactId or email is required");
+  }
+
+  const response = await intercomFetch<{ type: string; id: string }>(
+    "/messages",
+    {
+      method: "POST",
+      body: JSON.stringify(messageBody),
+    },
+  );
+
+  return response;
+}
+
+export async function getMe(): Promise<{ type: string; id: string; name: string; email: string }> {
+  const response = await intercomFetch<{ type: string; id: string; name: string; email: string }>(
+    "/me",
+  );
+  return response;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Intercom Token Store
+ */
+
+export { memoryTokenStore as tokenStore, type OAuthTokens, type TokenStore } from "veryfront/oauth";
+
+export async function getAccessToken(): Promise<string | null> {
+  const { tokenStore } = await import("./token-store.ts");
+  const tokens = await tokenStore.get("intercom");
+  return tokens?.accessToken ?? null;
+}

package/dist/integrations/jira/connector.json

@@ -0,0 +1,109 @@
+{
+  "name": "jira",
+  "displayName": "Jira",
+  "icon": "jira.svg",
+  "description": "Search, create, and manage Jira issues and projects",
+  "auth": {
+    "type": "oauth2",
+    "provider": "atlassian",
+    "authorizationUrl": "https://auth.atlassian.com/authorize",
+    "tokenUrl": "https://auth.atlassian.com/oauth/token",
+    "scopes": [
+      "read:jira-work",
+      "write:jira-work",
+      "read:jira-user",
+      "offline_access"
+    ],
+    "callbackPath": "/api/auth/jira/callback",
+    "tokenAuthMethod": "body",
+    "additionalAuthParams": {
+      "audience": "api.atlassian.com",
+      "prompt": "consent"
+    },
+    "requiredApis": [
+      {
+        "name": "Atlassian OAuth 2.0",
+        "enableUrl": "https://developer.atlassian.com/console/myapps/"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "ATLASSIAN_CLIENT_ID",
+      "description": "Atlassian OAuth 2.0 Client ID (from your app)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developer.atlassian.com/console/myapps/"
+    },
+    {
+      "name": "ATLASSIAN_CLIENT_SECRET",
+      "description": "Atlassian OAuth 2.0 Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developer.atlassian.com/console/myapps/"
+    }
+  ],
+  "tools": [
+    {
+      "id": "search-issues",
+      "name": "Search Issues",
+      "description": "Search Jira issues using JQL (Jira Query Language)",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-issue",
+      "name": "Get Issue",
+      "description": "Get detailed information about a specific Jira issue",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-issue",
+      "name": "Create Issue",
+      "description": "Create a new Jira issue in a project",
+      "requiresWrite": true
+    },
+    {
+      "id": "update-issue",
+      "name": "Update Issue",
+      "description": "Update an existing Jira issue (status, fields, etc.)",
+      "requiresWrite": true
+    },
+    {
+      "id": "list-projects",
+      "name": "List Projects",
+      "description": "List all accessible Jira projects",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "find-bugs",
+      "title": "Find open bugs",
+      "prompt": "Search for all open bugs assigned to me or in my current sprint.",
+      "category": "productivity",
+      "icon": "bug"
+    },
+    {
+      "id": "create-task",
+      "title": "Create a task",
+      "prompt": "Create a new task in Jira with a title, description, and priority.",
+      "category": "productivity",
+      "icon": "plus"
+    },
+    {
+      "id": "sprint-summary",
+      "title": "Sprint summary",
+      "prompt": "Get a summary of all issues in the current sprint, organized by status.",
+      "category": "productivity",
+      "icon": "list"
+    },
+    {
+      "id": "update-status",
+      "title": "Update issue status",
+      "prompt": "Move an issue to a different status (To Do, In Progress, Done, etc.).",
+      "category": "productivity",
+      "icon": "check"
+    }
+  ],
+  "suggestedWith": ["github", "slack", "confluence"]
+}

package/dist/integrations/jira/files/ai/tools/create-issue.ts

@@ -0,0 +1,47 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createIssue } from "../../lib/jira-client.ts";
+
+export default tool({
+  id: "create-issue",
+  description:
+    "Create a new Jira issue in a project. Requires project key, summary, and issue type. Optionally set description, priority, assignee, and labels.",
+  inputSchema: z.object({
+    projectKey: z.string().describe('The project key (e.g., "PROJ", "DEV")'),
+    summary: z.string().describe("Brief summary/title of the issue"),
+    issueType: z.string().describe('Type of issue: "Task", "Bug", "Story", "Epic", etc.'),
+    description: z.string().optional().describe("Detailed description of the issue"),
+    priority: z.string().optional().describe(
+      'Priority: "Highest", "High", "Medium", "Low", "Lowest"',
+    ),
+    assigneeId: z.string().optional().describe("Atlassian account ID of the assignee (optional)"),
+    labels: z.array(z.string()).optional().describe("Array of labels to add to the issue"),
+  }),
+  async execute({ projectKey, summary, issueType, description, priority, assigneeId, labels }) {
+    const issue = await createIssue({
+      projectKey,
+      summary,
+      issueType,
+      description,
+      priority,
+      assigneeId,
+      labels,
+    });
+
+    return {
+      key: issue.key,
+      id: issue.id,
+      summary: issue.fields.summary,
+      status: issue.fields.status.name,
+      type: issue.fields.issuetype.name,
+      priority: issue.fields.priority?.name,
+      assignee: issue.fields.assignee?.displayName,
+      project: {
+        key: issue.fields.project.key,
+        name: issue.fields.project.name,
+      },
+      created: issue.fields.created,
+      message: `Issue ${issue.key} created successfully`,
+    };
+  },
+});

package/dist/integrations/jira/files/ai/tools/get-issue.ts

@@ -0,0 +1,57 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { extractDescriptionText, getIssue } from "../../lib/jira-client.ts";
+
+export default tool({
+  id: "get-issue",
+  description:
+    "Get detailed information about a specific Jira issue by its key (e.g., PROJ-123) or ID. Returns all fields including description, comments, history, etc.",
+  inputSchema: z.object({
+    issueKey: z.string().describe('The issue key (e.g., "PROJ-123") or ID'),
+  }),
+  async execute({ issueKey }) {
+    const issue = await getIssue(issueKey);
+
+    return {
+      key: issue.key,
+      id: issue.id,
+      summary: issue.fields.summary,
+      description: extractDescriptionText(issue.fields.description),
+      status: issue.fields.status.name,
+      statusCategory: issue.fields.status.statusCategory.name,
+      type: {
+        name: issue.fields.issuetype.name,
+        iconUrl: issue.fields.issuetype.iconUrl,
+      },
+      priority: issue.fields.priority
+        ? {
+          name: issue.fields.priority.name,
+          iconUrl: issue.fields.priority.iconUrl,
+        }
+        : null,
+      assignee: issue.fields.assignee
+        ? {
+          displayName: issue.fields.assignee.displayName,
+          email: issue.fields.assignee.emailAddress,
+          accountId: issue.fields.assignee.accountId,
+        }
+        : null,
+      reporter: issue.fields.reporter
+        ? {
+          displayName: issue.fields.reporter.displayName,
+          email: issue.fields.reporter.emailAddress,
+          accountId: issue.fields.reporter.accountId,
+        }
+        : null,
+      project: {
+        key: issue.fields.project.key,
+        name: issue.fields.project.name,
+        id: issue.fields.project.id,
+      },
+      created: issue.fields.created,
+      updated: issue.fields.updated,
+      labels: issue.fields.labels || [],
+      url: issue.self,
+    };
+  },
+});

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

@@ -0,0 +1,30 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listProjects } from "../../lib/jira-client.ts";
+
+export default tool({
+  id: "list-projects",
+  description:
+    "List all accessible Jira projects in the connected site. Returns project keys, names, and basic information.",
+  inputSchema: z.object({}),
+  async execute() {
+    const projects = await listProjects();
+
+    return {
+      total: projects.length,
+      projects: projects.map((project) => ({
+        key: project.key,
+        id: project.id,
+        name: project.name,
+        projectType: project.projectTypeKey,
+        lead: project.lead
+          ? {
+            displayName: project.lead.displayName,
+            accountId: project.lead.accountId,
+          }
+          : null,
+        avatarUrl: project.avatarUrls?.["48x48"],
+      })),
+    };
+  },
+});

package/dist/integrations/jira/files/ai/tools/search-issues.ts

@@ -0,0 +1,49 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { extractDescriptionText, searchIssues } from "../../lib/jira-client.ts";
+
+export default tool({
+  id: "search-issues",
+  description:
+    'Search for Jira issues using JQL (Jira Query Language). Returns matching issues with key details. Common JQL examples: "assignee = currentUser() AND status != Done", "project = PROJ AND type = Bug", "created >= -7d".',
+  inputSchema: z.object({
+    jql: z.string().describe(
+      'JQL query string to search issues. Examples: "assignee = currentUser()", "project = PROJ", "status = Open"',
+    ),
+    maxResults: z.number().min(1).max(100).default(20).describe(
+      "Maximum number of results to return",
+    ),
+    fields: z.array(z.string()).optional().describe(
+      'Specific fields to include (e.g., ["summary", "status", "assignee"])',
+    ),
+  }),
+  async execute({ jql, maxResults, fields }) {
+    const result = await searchIssues(jql, {
+      maxResults,
+      fields,
+    });
+
+    return {
+      total: result.total,
+      issues: result.issues.map((issue) => ({
+        key: issue.key,
+        id: issue.id,
+        summary: issue.fields.summary,
+        description: extractDescriptionText(issue.fields.description),
+        status: issue.fields.status.name,
+        statusCategory: issue.fields.status.statusCategory.name,
+        type: issue.fields.issuetype.name,
+        priority: issue.fields.priority?.name,
+        assignee: issue.fields.assignee?.displayName,
+        reporter: issue.fields.reporter?.displayName,
+        project: {
+          key: issue.fields.project.key,
+          name: issue.fields.project.name,
+        },
+        created: issue.fields.created,
+        updated: issue.fields.updated,
+        labels: issue.fields.labels || [],
+      })),
+    };
+  },
+});