veryfront 0.0.49 → 0.0.51

package/dist/integrations/linear/files/ai/tools/update-issue.ts

@@ -0,0 +1,71 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { updateIssue } from "../../lib/linear-client.ts";
+
+export default tool({
+  id: "update-issue",
+  description:
+    "Update an existing Linear issue. You can change the title, description, status, priority, assignee, project, or labels.",
+  inputSchema: z.object({
+    issueId: z.string().describe("The ID of the issue to update"),
+    title: z.string().optional().describe("New title for the issue"),
+    description: z.string().optional().describe(
+      "New description for the issue (supports markdown)",
+    ),
+    priority: z.number().min(0).max(4).optional().describe(
+      "New priority level: 0=No priority, 1=Urgent, 2=High, 3=Medium, 4=Low",
+    ),
+    stateId: z.string().optional().describe("New workflow state ID to move the issue to"),
+    assigneeId: z.string().optional().describe(
+      "User ID to assign the issue to (or null to unassign)",
+    ),
+    projectId: z.string().optional().describe("Project ID to move the issue to"),
+    labelIds: z.array(z.string()).optional().describe(
+      "New array of label IDs (replaces existing labels)",
+    ),
+  }),
+  async execute(
+    { issueId, title, description, priority, stateId, assigneeId, projectId, labelIds },
+  ) {
+    const issue = await updateIssue(issueId, {
+      title,
+      description,
+      priority,
+      stateId,
+      assigneeId,
+      projectId,
+      labelIds,
+    });
+
+    return {
+      id: issue.id,
+      identifier: issue.identifier,
+      title: issue.title,
+      description: issue.description,
+      priority: issue.priorityLabel,
+      status: issue.state.name,
+      statusType: issue.state.type,
+      assignee: issue.assignee
+        ? {
+          name: issue.assignee.name,
+          email: issue.assignee.email,
+        }
+        : null,
+      team: {
+        name: issue.team.name,
+        key: issue.team.key,
+      },
+      project: issue.project
+        ? {
+          name: issue.project.name,
+        }
+        : null,
+      labels: issue.labels.nodes.map((label) => ({
+        name: label.name,
+        color: label.color,
+      })),
+      url: issue.url,
+      updatedAt: issue.updatedAt,
+    };
+  },
+});

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

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

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

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

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

@@ -0,0 +1,464 @@
+import { getAccessToken } from "./token-store.ts";
+
+const LINEAR_API_URL = "https://api.linear.app/graphql";
+
+// Type definitions for Linear API responses
+export interface LinearIssue {
+  id: string;
+  identifier: string;
+  title: string;
+  description?: string;
+  priority: number;
+  priorityLabel: string;
+  state: {
+    id: string;
+    name: string;
+    type: string;
+  };
+  assignee?: {
+    id: string;
+    name: string;
+    email: string;
+  };
+  team: {
+    id: string;
+    name: string;
+    key: string;
+  };
+  project?: {
+    id: string;
+    name: string;
+  };
+  labels: {
+    nodes: Array<{
+      id: string;
+      name: string;
+      color: string;
+    }>;
+  };
+  createdAt: string;
+  updatedAt: string;
+  url: string;
+}
+
+export interface LinearProject {
+  id: string;
+  name: string;
+  description?: string;
+  state: string;
+  progress: number;
+  url: string;
+  lead?: {
+    id: string;
+    name: string;
+  };
+  teams: {
+    nodes: Array<{
+      id: string;
+      name: string;
+      key: string;
+    }>;
+  };
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface LinearTeam {
+  id: string;
+  name: string;
+  key: string;
+}
+
+export interface LinearWorkflowState {
+  id: string;
+  name: string;
+  type: string;
+}
+
+interface GraphQLResponse<T> {
+  data?: T;
+  errors?: Array<{
+    message: string;
+    path?: string[];
+  }>;
+}
+
+async function linearFetch<T>(query: string, variables?: Record<string, unknown>): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Linear. Please connect your account.");
+  }
+
+  const response = await fetch(LINEAR_API_URL, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      query,
+      variables,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Linear API error: ${response.status} ${response.statusText}`);
+  }
+
+  const json = await response.json() as GraphQLResponse<T>;
+
+  if (json.errors && json.errors.length > 0) {
+    throw new Error(`Linear GraphQL error: ${json.errors[0].message}`);
+  }
+
+  if (!json.data) {
+    throw new Error("Linear API returned no data");
+  }
+
+  return json.data;
+}
+
+export async function searchIssues(
+  query: string,
+  options?: {
+    limit?: number;
+    includeArchived?: boolean;
+  },
+): Promise<LinearIssue[]> {
+  const gqlQuery = `
+    query SearchIssues($query: String!, $first: Int, $includeArchived: Boolean) {
+      issueSearch(query: $query, first: $first, includeArchived: $includeArchived) {
+        nodes {
+          id
+          identifier
+          title
+          description
+          priority
+          priorityLabel
+          state {
+            id
+            name
+            type
+          }
+          assignee {
+            id
+            name
+            email
+          }
+          team {
+            id
+            name
+            key
+          }
+          project {
+            id
+            name
+          }
+          labels {
+            nodes {
+              id
+              name
+              color
+            }
+          }
+          createdAt
+          updatedAt
+          url
+        }
+      }
+    }
+  `;
+
+  const data = await linearFetch<{
+    issueSearch: { nodes: LinearIssue[] };
+  }>(gqlQuery, {
+    query,
+    first: options?.limit || 10,
+    includeArchived: options?.includeArchived || false,
+  });
+
+  return data.issueSearch.nodes;
+}
+
+export function getIssue(issueId: string): Promise<LinearIssue> {
+  const query = `
+    query GetIssue($id: String!) {
+      issue(id: $id) {
+        id
+        identifier
+        title
+        description
+        priority
+        priorityLabel
+        state {
+          id
+          name
+          type
+        }
+        assignee {
+          id
+          name
+          email
+        }
+        team {
+          id
+          name
+          key
+        }
+        project {
+          id
+          name
+        }
+        labels {
+          nodes {
+            id
+            name
+            color
+          }
+        }
+        createdAt
+        updatedAt
+        url
+      }
+    }
+  `;
+
+  return linearFetch<{ issue: LinearIssue }>(query, { id: issueId }).then((data) => data.issue);
+}
+
+export function createIssue(options: {
+  teamId: string;
+  title: string;
+  description?: string;
+  priority?: number;
+  stateId?: string;
+  assigneeId?: string;
+  projectId?: string;
+  labelIds?: string[];
+}): Promise<LinearIssue> {
+  const mutation = `
+    mutation CreateIssue($input: IssueCreateInput!) {
+      issueCreate(input: $input) {
+        success
+        issue {
+          id
+          identifier
+          title
+          description
+          priority
+          priorityLabel
+          state {
+            id
+            name
+            type
+          }
+          assignee {
+            id
+            name
+            email
+          }
+          team {
+            id
+            name
+            key
+          }
+          project {
+            id
+            name
+          }
+          labels {
+            nodes {
+              id
+              name
+              color
+            }
+          }
+          createdAt
+          updatedAt
+          url
+        }
+      }
+    }
+  `;
+
+  const input: Record<string, unknown> = {
+    teamId: options.teamId,
+    title: options.title,
+  };
+
+  if (options.description) input.description = options.description;
+  if (options.priority !== undefined) input.priority = options.priority;
+  if (options.stateId) input.stateId = options.stateId;
+  if (options.assigneeId) input.assigneeId = options.assigneeId;
+  if (options.projectId) input.projectId = options.projectId;
+  if (options.labelIds && options.labelIds.length > 0) input.labelIds = options.labelIds;
+
+  return linearFetch<{
+    issueCreate: { success: boolean; issue: LinearIssue };
+  }>(mutation, { input }).then((data) => {
+    if (!data.issueCreate.success) {
+      throw new Error("Failed to create issue");
+    }
+    return data.issueCreate.issue;
+  });
+}
+
+export async function updateIssue(
+  issueId: string,
+  options: {
+    title?: string;
+    description?: string;
+    priority?: number;
+    stateId?: string;
+    assigneeId?: string;
+    projectId?: string;
+    labelIds?: string[];
+  },
+): Promise<LinearIssue> {
+  const mutation = `
+    mutation UpdateIssue($id: String!, $input: IssueUpdateInput!) {
+      issueUpdate(id: $id, input: $input) {
+        success
+        issue {
+          id
+          identifier
+          title
+          description
+          priority
+          priorityLabel
+          state {
+            id
+            name
+            type
+          }
+          assignee {
+            id
+            name
+            email
+          }
+          team {
+            id
+            name
+            key
+          }
+          project {
+            id
+            name
+            }
+          labels {
+            nodes {
+              id
+              name
+              color
+            }
+          }
+          createdAt
+          updatedAt
+          url
+        }
+      }
+    }
+  `;
+
+  const input: Record<string, unknown> = {};
+
+  if (options.title) input.title = options.title;
+  if (options.description !== undefined) input.description = options.description;
+  if (options.priority !== undefined) input.priority = options.priority;
+  if (options.stateId) input.stateId = options.stateId;
+  if (options.assigneeId) input.assigneeId = options.assigneeId;
+  if (options.projectId) input.projectId = options.projectId;
+  if (options.labelIds) input.labelIds = options.labelIds;
+
+  const data = await linearFetch<{
+    issueUpdate: { success: boolean; issue: LinearIssue };
+  }>(mutation, { id: issueId, input });
+
+  if (!data.issueUpdate.success) {
+    throw new Error("Failed to update issue");
+  }
+
+  return data.issueUpdate.issue;
+}
+
+export async function listProjects(options?: {
+  limit?: number;
+  includeArchived?: boolean;
+}): Promise<LinearProject[]> {
+  const query = `
+    query ListProjects($first: Int, $includeArchived: Boolean) {
+      projects(first: $first, includeArchived: $includeArchived) {
+        nodes {
+          id
+          name
+          description
+          state
+          progress
+          url
+          lead {
+            id
+            name
+          }
+          teams {
+            nodes {
+              id
+              name
+              key
+            }
+          }
+          createdAt
+          updatedAt
+        }
+      }
+    }
+  `;
+
+  const data = await linearFetch<{
+    projects: { nodes: LinearProject[] };
+  }>(query, {
+    first: options?.limit || 20,
+    includeArchived: options?.includeArchived || false,
+  });
+
+  return data.projects.nodes;
+}
+
+export function getTeams(): Promise<LinearTeam[]> {
+  const query = `
+    query GetTeams {
+      teams {
+        nodes {
+          id
+          name
+          key
+        }
+      }
+    }
+  `;
+
+  return linearFetch<{
+    teams: { nodes: LinearTeam[] };
+  }>(query).then((data) => data.teams.nodes);
+}
+
+export async function getWorkflowStates(teamId: string): Promise<LinearWorkflowState[]> {
+  const query = `
+    query GetWorkflowStates($teamId: String!) {
+      team(id: $teamId) {
+        states {
+          nodes {
+            id
+            name
+            type
+          }
+        }
+      }
+    }
+  `;
+
+  const data = await linearFetch<{
+    team: { states: { nodes: LinearWorkflowState[] } };
+  }>(query, { teamId });
+
+  return data.team.states.nodes;
+}

package/dist/integrations/mailchimp/connector.json

@@ -0,0 +1,85 @@
+{
+  "name": "mailchimp",
+  "displayName": "Mailchimp",
+  "icon": "mailchimp.svg",
+  "description": "Manage email campaigns, lists, and subscribers in Mailchimp",
+  "auth": {
+    "type": "oauth2",
+    "provider": "mailchimp",
+    "authorizationUrl": "https://login.mailchimp.com/oauth2/authorize",
+    "tokenUrl": "https://login.mailchimp.com/oauth2/token",
+    "scopes": [],
+    "callbackPath": "/api/auth/mailchimp/callback",
+    "requiredApis": [
+      {
+        "name": "Mailchimp API",
+        "enableUrl": "https://admin.mailchimp.com/account/oauth2/"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "MAILCHIMP_CLIENT_ID",
+      "description": "Mailchimp OAuth Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://mailchimp.com/developer/marketing/guides/access-user-data-oauth-2/"
+    },
+    {
+      "name": "MAILCHIMP_CLIENT_SECRET",
+      "description": "Mailchimp OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://mailchimp.com/developer/marketing/guides/access-user-data-oauth-2/"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-campaigns",
+      "name": "List Campaigns",
+      "description": "List all email campaigns in Mailchimp",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-campaign",
+      "name": "Get Campaign",
+      "description": "Get details of a specific campaign",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-lists",
+      "name": "List Audience Lists",
+      "description": "List all audience lists (mailing lists) in Mailchimp",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-list",
+      "name": "Get Audience List",
+      "description": "Get details of a specific audience list",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-members",
+      "name": "List Members",
+      "description": "List subscribers/members in an audience list",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "campaign-stats",
+      "title": "Show campaign stats",
+      "prompt": "Show me the performance statistics for my recent email campaigns in Mailchimp.",
+      "category": "marketing",
+      "icon": "chart"
+    },
+    {
+      "id": "list-subscribers",
+      "title": "List subscribers",
+      "prompt": "Show me the subscribers in my main email list with their subscription status.",
+      "category": "marketing",
+      "icon": "users"
+    }
+  ],
+  "suggestedWith": ["slack", "notion", "hubspot"]
+}

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

@@ -0,0 +1,4 @@
+# Mailchimp OAuth Configuration
+# Get your credentials from https://admin.mailchimp.com/account/oauth2/
+MAILCHIMP_CLIENT_ID=your-client-id
+MAILCHIMP_CLIENT_SECRET=your-client-secret

package/dist/integrations/mailchimp/files/ai/tools/get-campaign.ts

@@ -0,0 +1,45 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getCampaign } from "../../lib/mailchimp-client.ts";
+
+export default tool({
+  id: "get-campaign",
+  description: "Get details of a specific Mailchimp campaign by its ID.",
+  inputSchema: z.object({
+    campaignId: z.string().describe("The ID of the campaign to retrieve"),
+  }),
+  async execute({ campaignId }) {
+    const campaign = await getCampaign(campaignId);
+
+    return {
+      id: campaign.id,
+      webId: campaign.web_id,
+      type: campaign.type,
+      status: campaign.status,
+      title: campaign.settings.title,
+      subject: campaign.settings.subject_line,
+      previewText: campaign.settings.preview_text,
+      fromName: campaign.settings.from_name,
+      replyTo: campaign.settings.reply_to,
+      listId: campaign.recipients.list_id,
+      listName: campaign.recipients.list_name,
+      segmentText: campaign.recipients.segment_text,
+      emailsSent: campaign.emails_sent,
+      sendTime: campaign.send_time,
+      createdAt: campaign.create_time,
+      archiveUrl: campaign.archive_url,
+      longArchiveUrl: campaign.long_archive_url,
+      tracking: campaign.tracking,
+      reportSummary: campaign.report_summary
+        ? {
+            opens: campaign.report_summary.opens,
+            uniqueOpens: campaign.report_summary.unique_opens,
+            openRate: campaign.report_summary.open_rate,
+            clicks: campaign.report_summary.clicks,
+            subscriberClicks: campaign.report_summary.subscriber_clicks,
+            clickRate: campaign.report_summary.click_rate,
+          }
+        : undefined,
+    };
+  },
+});