veryfront 0.0.48 → 0.0.50

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

@@ -0,0 +1,259 @@
+import { getAccessToken } from "./token-store.ts";
+
+const PIPEDRIVE_BASE_URL = "https://api.pipedrive.com/v1";
+
+interface PipedriveResponse<T> {
+  success: boolean;
+  data: T;
+  additional_data?: {
+    pagination?: {
+      start: number;
+      limit: number;
+      more_items_in_collection: boolean;
+      next_start?: number;
+    };
+  };
+}
+
+interface PipedriveDeal {
+  id: number;
+  title: string;
+  value: number;
+  currency: string;
+  status: string;
+  stage_id: number;
+  person_id: number | null;
+  person_name: string | null;
+  org_id: number | null;
+  org_name: string | null;
+  owner_name: string;
+  expected_close_date: string | null;
+  add_time: string;
+  update_time: string;
+  won_time: string | null;
+  lost_time: string | null;
+  close_time: string | null;
+}
+
+interface PipedrivePerson {
+  id: number;
+  name: string;
+  first_name: string;
+  last_name: string;
+  email: Array<{ value: string; primary: boolean }>;
+  phone: Array<{ value: string; primary: boolean }>;
+  org_id: number | null;
+  org_name: string | null;
+  owner_id: number;
+  owner_name: string;
+  add_time: string;
+  update_time: string;
+}
+
+interface PipedriveOrganization {
+  id: number;
+  name: string;
+  owner_id: number;
+  owner_name: string;
+  address: string | null;
+  add_time: string;
+  update_time: string;
+}
+
+interface PipedriveStage {
+  id: number;
+  name: string;
+  order_nr: number;
+  pipeline_id: number;
+  pipeline_name: string;
+}
+
+async function pipedriveFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Pipedrive. Please connect your account.");
+  }
+
+  const url = new URL(`${PIPEDRIVE_BASE_URL}${endpoint}`);
+  url.searchParams.set("api_token", token);
+
+  const response = await fetch(url.toString(), {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Pipedrive API error: ${response.status} ${error.error || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function listDeals(options?: {
+  status?: "open" | "won" | "lost" | "all";
+  ownerId?: number;
+  stageId?: number;
+  limit?: number;
+}): Promise<PipedriveDeal[]> {
+  const params = new URLSearchParams();
+
+  if (options?.status) {
+    params.set("status", options.status);
+  }
+  if (options?.ownerId) {
+    params.set("user_id", options.ownerId.toString());
+  }
+  if (options?.stageId) {
+    params.set("stage_id", options.stageId.toString());
+  }
+  if (options?.limit) {
+    params.set("limit", options.limit.toString());
+  }
+
+  const queryString = params.toString();
+  const endpoint = queryString ? `/deals?${queryString}` : "/deals";
+
+  const response = await pipedriveFetch<PipedriveResponse<PipedriveDeal[]>>(endpoint);
+  return response.data || [];
+}
+
+export async function getDeal(dealId: number): Promise<PipedriveDeal> {
+  const response = await pipedriveFetch<PipedriveResponse<PipedriveDeal>>(
+    `/deals/${dealId}`,
+  );
+  return response.data;
+}
+
+export async function createDeal(options: {
+  title: string;
+  value?: number;
+  currency?: string;
+  personId?: number;
+  orgId?: number;
+  stageId?: number;
+  expectedCloseDate?: string;
+}): Promise<PipedriveDeal> {
+  const body: Record<string, unknown> = {
+    title: options.title,
+  };
+
+  if (options.value !== undefined) body.value = options.value;
+  if (options.currency) body.currency = options.currency;
+  if (options.personId) body.person_id = options.personId;
+  if (options.orgId) body.org_id = options.orgId;
+  if (options.stageId) body.stage_id = options.stageId;
+  if (options.expectedCloseDate) body.expected_close_date = options.expectedCloseDate;
+
+  const response = await pipedriveFetch<PipedriveResponse<PipedriveDeal>>("/deals", {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+  return response.data;
+}
+
+export async function updateDeal(
+  dealId: number,
+  updates: {
+    title?: string;
+    value?: number;
+    status?: string;
+    stageId?: number;
+    personId?: number;
+    orgId?: number;
+    expectedCloseDate?: string;
+  },
+): Promise<PipedriveDeal> {
+  const body: Record<string, unknown> = {};
+
+  if (updates.title !== undefined) body.title = updates.title;
+  if (updates.value !== undefined) body.value = updates.value;
+  if (updates.status !== undefined) body.status = updates.status;
+  if (updates.stageId !== undefined) body.stage_id = updates.stageId;
+  if (updates.personId !== undefined) body.person_id = updates.personId;
+  if (updates.orgId !== undefined) body.org_id = updates.orgId;
+  if (updates.expectedCloseDate !== undefined) body.expected_close_date = updates.expectedCloseDate;
+
+  const response = await pipedriveFetch<PipedriveResponse<PipedriveDeal>>(
+    `/deals/${dealId}`,
+    {
+      method: "PUT",
+      body: JSON.stringify(body),
+    },
+  );
+  return response.data;
+}
+
+export async function listPersons(options?: {
+  searchTerm?: string;
+  limit?: number;
+}): Promise<PipedrivePerson[]> {
+  const params = new URLSearchParams();
+
+  if (options?.searchTerm) {
+    params.set("term", options.searchTerm);
+  }
+  if (options?.limit) {
+    params.set("limit", options.limit.toString());
+  }
+
+  const queryString = params.toString();
+  const endpoint = queryString ? `/persons?${queryString}` : "/persons";
+
+  const response = await pipedriveFetch<PipedriveResponse<PipedrivePerson[]>>(endpoint);
+  return response.data || [];
+}
+
+export async function getPerson(personId: number): Promise<PipedrivePerson> {
+  const response = await pipedriveFetch<PipedriveResponse<PipedrivePerson>>(
+    `/persons/${personId}`,
+  );
+  return response.data;
+}
+
+export async function createPerson(options: {
+  name: string;
+  email?: string;
+  phone?: string;
+  orgId?: number;
+}): Promise<PipedrivePerson> {
+  const body: Record<string, unknown> = {
+    name: options.name,
+  };
+
+  if (options.email) {
+    body.email = [{ value: options.email, primary: true }];
+  }
+  if (options.phone) {
+    body.phone = [{ value: options.phone, primary: true }];
+  }
+  if (options.orgId) {
+    body.org_id = options.orgId;
+  }
+
+  const response = await pipedriveFetch<PipedriveResponse<PipedrivePerson>>("/persons", {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+  return response.data;
+}
+
+export async function listStages(): Promise<PipedriveStage[]> {
+  const response = await pipedriveFetch<PipedriveResponse<PipedriveStage[]>>("/stages");
+  return response.data || [];
+}
+
+export async function getCurrentUser(): Promise<{ id: number; name: string; email: string }> {
+  const response = await pipedriveFetch<PipedriveResponse<{ id: number; name: string; email: string }>>(
+    "/users/me",
+  );
+  return response.data;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Pipedrive 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("pipedrive");
+  return tokens?.accessToken ?? null;
+}

package/dist/integrations/posthog/connector.json

@@ -0,0 +1,84 @@
+{
+  "name": "posthog",
+  "displayName": "PostHog",
+  "icon": "posthog.svg",
+  "description": "Access analytics, feature flags, and user insights from PostHog",
+  "auth": {
+    "type": "api-key",
+    "keyName": "POSTHOG_API_KEY",
+    "headerName": "Authorization",
+    "headerPrefix": "Bearer",
+    "requiredApis": [
+      {
+        "name": "PostHog API",
+        "enableUrl": "https://app.posthog.com/project/settings"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "POSTHOG_API_KEY",
+      "description": "PostHog Personal API Key",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://posthog.com/docs/api/overview"
+    },
+    {
+      "name": "POSTHOG_HOST",
+      "description": "PostHog API host (defaults to https://app.posthog.com)",
+      "required": false,
+      "sensitive": false,
+      "docsUrl": "https://posthog.com/docs/self-host"
+    }
+  ],
+  "tools": [
+    {
+      "id": "get-trends",
+      "name": "Get Trends",
+      "description": "Retrieve event trends and analytics data",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-feature-flags",
+      "name": "List Feature Flags",
+      "description": "List all feature flags in your PostHog project",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-persons",
+      "name": "List Persons",
+      "description": "List persons/users tracked in PostHog",
+      "requiresWrite": false
+    },
+    {
+      "id": "capture-event",
+      "name": "Capture Event",
+      "description": "Track a custom event in PostHog",
+      "requiresWrite": true
+    }
+  ],
+  "prompts": [
+    {
+      "id": "trend-analysis",
+      "title": "Trend analysis",
+      "prompt": "Show me the trends for key events in my PostHog project over the last 7 days.",
+      "category": "analytics",
+      "icon": "chart"
+    },
+    {
+      "id": "feature-flag-status",
+      "title": "Feature flag status",
+      "prompt": "List all active feature flags and their current rollout status.",
+      "category": "analytics",
+      "icon": "flag"
+    },
+    {
+      "id": "user-insights",
+      "title": "User insights",
+      "prompt": "Give me insights about recent user activity and top users in my PostHog project.",
+      "category": "analytics",
+      "icon": "users"
+    }
+  ],
+  "suggestedWith": ["slack", "analytics", "monitoring"]
+}

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

@@ -0,0 +1,6 @@
+# PostHog Integration
+# Get your API key at https://app.posthog.com/project/settings
+# Create a Personal API Key for server-side access
+
+POSTHOG_API_KEY=phx_your_api_key_here
+POSTHOG_HOST=https://app.posthog.com

package/dist/integrations/posthog/files/ai/tools/capture-event.ts

@@ -0,0 +1,37 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { captureEvent } from "../../lib/posthog-client.ts";
+
+export default tool({
+  id: "capture-event",
+  description:
+    "Track a custom event in PostHog. Capture user actions, page views, or any custom analytics event.",
+  inputSchema: z.object({
+    event: z.string().describe("Event name (e.g., 'button_clicked', 'page_viewed')"),
+    distinctId: z.string().describe("Unique identifier for the user or session"),
+    properties: z.record(z.unknown()).optional().describe(
+      "Additional properties to attach to the event",
+    ),
+    timestamp: z.string().optional().describe(
+      "Event timestamp in ISO format (defaults to current time)",
+    ),
+  }),
+  async execute({ event, distinctId, properties, timestamp }) {
+    const result = await captureEvent({
+      event,
+      distinct_id: distinctId,
+      properties,
+      timestamp,
+    });
+
+    return {
+      success: result.status === 1 || result.status === 200,
+      event: {
+        name: event,
+        distinctId,
+        properties,
+        timestamp: timestamp || new Date().toISOString(),
+      },
+    };
+  },
+});

package/dist/integrations/posthog/files/ai/tools/get-trends.ts

@@ -0,0 +1,44 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getTrends } from "../../lib/posthog-client.ts";
+
+export default tool({
+  id: "get-trends",
+  description:
+    "Retrieve event trends and analytics data from PostHog. Analyze how events are trending over time.",
+  inputSchema: z.object({
+    events: z.array(
+      z.object({
+        id: z.string().describe("Event ID or name (e.g., '$pageview', 'button_clicked')"),
+        name: z.string().optional().describe("Display name for the event"),
+        type: z.string().optional().default("events").describe("Event type"),
+      }),
+    ).optional().describe("List of events to analyze (defaults to $pageview)"),
+    dateFrom: z.string().optional().default("-7d").describe(
+      "Start date in ISO format or relative (e.g., '-7d', '-30d')",
+    ),
+    dateTo: z.string().optional().default("now").describe(
+      "End date in ISO format or relative (e.g., 'now', '-1d')",
+    ),
+    interval: z.enum(["hour", "day", "week", "month"]).optional().default("day").describe(
+      "Time interval for aggregation",
+    ),
+  }),
+  async execute({ events, dateFrom, dateTo, interval }) {
+    const trends = await getTrends({
+      events,
+      date_from: dateFrom,
+      date_to: dateTo,
+      interval,
+    });
+
+    return trends.map((trend) => ({
+      label: trend.label,
+      count: trend.count,
+      data: trend.data,
+      labels: trend.labels,
+      days: trend.days,
+      action: trend.action,
+    }));
+  },
+});

package/dist/integrations/posthog/files/ai/tools/list-feature-flags.ts

@@ -0,0 +1,38 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatDate, getFeatureFlags } from "../../lib/posthog-client.ts";
+
+export default tool({
+  id: "list-feature-flags",
+  description:
+    "List all feature flags in your PostHog project. View flag status, rollout percentages, and configuration.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(100).default(20).describe(
+      "Maximum number of feature flags to retrieve",
+    ),
+  }),
+  async execute({ limit }) {
+    const response = await getFeatureFlags({ limit });
+
+    return {
+      count: response.results.length,
+      flags: response.results.map((flag) => ({
+        id: flag.id,
+        name: flag.name,
+        key: flag.key,
+        active: flag.active,
+        deleted: flag.deleted,
+        isSimpleFlag: flag.is_simple_flag,
+        rolloutPercentage: flag.rollout_percentage,
+        createdAt: formatDate(flag.created_at),
+        createdBy: flag.created_by
+          ? {
+            name: flag.created_by.first_name,
+            email: flag.created_by.email,
+          }
+          : null,
+        filters: flag.filters,
+      })),
+    };
+  },
+});

package/dist/integrations/posthog/files/ai/tools/list-persons.ts

@@ -0,0 +1,32 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { formatDate, listPersons } from "../../lib/posthog-client.ts";
+
+export default tool({
+  id: "list-persons",
+  description:
+    "List persons/users tracked in PostHog. View user properties, distinct IDs, and activity.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(100).default(20).describe(
+      "Maximum number of persons to retrieve",
+    ),
+    search: z.string().optional().describe(
+      "Search query to filter persons by properties or distinct ID",
+    ),
+  }),
+  async execute({ limit, search }) {
+    const response = await listPersons({ limit, search });
+
+    return {
+      count: response.results.length,
+      persons: response.results.map((person) => ({
+        id: person.id,
+        uuid: person.uuid,
+        name: person.name,
+        distinctIds: person.distinct_ids,
+        properties: person.properties,
+        createdAt: formatDate(person.created_at),
+      })),
+    };
+  },
+});