veryfront 0.0.48 → 0.0.50

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

@@ -0,0 +1,43 @@
+// In-memory token store for development
+// For production, replace with a secure database-backed implementation
+
+let projectToken: string | null = null;
+let apiSecret: string | null = null;
+let projectId: string | null = null;
+
+export function setProjectToken(token: string): void {
+  projectToken = token;
+}
+
+export function getProjectToken(): string | null {
+  // Try environment variable first, then in-memory store
+  return process.env.MIXPANEL_PROJECT_TOKEN || projectToken;
+}
+
+export function setApiSecret(secret: string): void {
+  apiSecret = secret;
+}
+
+export function getApiSecret(): string | null {
+  // Try environment variable first, then in-memory store
+  return process.env.MIXPANEL_API_SECRET || apiSecret;
+}
+
+export function setProjectId(id: string): void {
+  projectId = id;
+}
+
+export function getProjectId(): string | null {
+  // Try environment variable first, then in-memory store
+  return process.env.MIXPANEL_PROJECT_ID || projectId;
+}
+
+export function clearTokens(): void {
+  projectToken = null;
+  apiSecret = null;
+  projectId = null;
+}
+
+export function isAuthenticated(): boolean {
+  return getProjectToken() !== null && getApiSecret() !== null && getProjectId() !== null;
+}

package/dist/integrations/monday/connector.json

@@ -0,0 +1,85 @@
+{
+  "name": "monday",
+  "displayName": "Monday.com",
+  "icon": "monday.svg",
+  "description": "Manage projects, tasks, and workflows in Monday.com",
+  "auth": {
+    "type": "oauth2",
+    "provider": "monday",
+    "authorizationUrl": "https://auth.monday.com/oauth2/authorize",
+    "tokenUrl": "https://auth.monday.com/oauth2/token",
+    "scopes": ["me:read", "boards:read", "boards:write"],
+    "callbackPath": "/api/auth/monday/callback",
+    "requiredApis": [
+      {
+        "name": "Monday.com Developers",
+        "enableUrl": "https://monday.com/developers/apps"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "MONDAY_CLIENT_ID",
+      "description": "Monday.com OAuth Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developer.monday.com/apps/docs/oauth"
+    },
+    {
+      "name": "MONDAY_CLIENT_SECRET",
+      "description": "Monday.com OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developer.monday.com/apps/docs/oauth"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-boards",
+      "name": "List Boards",
+      "description": "List all boards in the workspace",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-items",
+      "name": "List Items",
+      "description": "List items in a board",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-item",
+      "name": "Get Item",
+      "description": "Get details of a specific item",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-item",
+      "name": "Create Item",
+      "description": "Create a new item in a board",
+      "requiresWrite": true
+    },
+    {
+      "id": "update-item",
+      "name": "Update Item",
+      "description": "Update an existing item",
+      "requiresWrite": true
+    }
+  ],
+  "prompts": [
+    {
+      "id": "my-items",
+      "title": "Show my items",
+      "prompt": "List all items assigned to me in Monday.com with their status and due dates.",
+      "category": "productivity",
+      "icon": "list"
+    },
+    {
+      "id": "create-item",
+      "title": "Create an item",
+      "prompt": "Create a new item with a name, status, and assign it to someone.",
+      "category": "productivity",
+      "icon": "plus"
+    }
+  ],
+  "suggestedWith": ["slack", "notion", "asana"]
+}

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

@@ -0,0 +1,4 @@
+# Monday.com OAuth Configuration
+# Get your credentials from https://monday.com/developers/apps
+MONDAY_CLIENT_ID=your-client-id
+MONDAY_CLIENT_SECRET=your-client-secret

package/dist/integrations/monday/files/ai/tools/create-item.ts

@@ -0,0 +1,36 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createItem } from "../../lib/monday-client.ts";
+
+export default tool({
+  id: "create-item",
+  description: "Create a new item in a Monday.com board. Items are the rows in a board.",
+  inputSchema: z.object({
+    boardId: z.string().describe("The ID of the board to create the item in"),
+    itemName: z.string().describe("The name/title of the item"),
+    groupId: z.string().optional().describe("Optional group ID within the board to add the item to"),
+    columnValues: z.record(z.unknown()).optional().describe(
+      "Optional column values as a key-value object. Keys are column IDs, values depend on column type.",
+    ),
+  }),
+  async execute({ boardId, itemName, groupId, columnValues }) {
+    const item = await createItem({
+      boardId,
+      itemName,
+      groupId,
+      columnValues,
+    });
+
+    return {
+      success: true,
+      item: {
+        id: item.id,
+        name: item.name,
+        state: item.state,
+        board: item.board,
+        group: item.group,
+        createdAt: item.created_at,
+      },
+    };
+  },
+});

package/dist/integrations/monday/files/ai/tools/get-item.ts

@@ -0,0 +1,31 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getItem } from "../../lib/monday-client.ts";
+
+export default tool({
+  id: "get-item",
+  description: "Get details of a specific Monday.com item by its ID.",
+  inputSchema: z.object({
+    itemId: z.string().describe("The ID of the item to retrieve"),
+  }),
+  async execute({ itemId }) {
+    const item = await getItem(itemId);
+
+    return {
+      id: item.id,
+      name: item.name,
+      state: item.state,
+      board: item.board,
+      group: item.group,
+      columnValues: item.column_values?.map((col) => ({
+        id: col.id,
+        title: col.title,
+        text: col.text,
+        type: col.type,
+        value: col.value,
+      })),
+      createdAt: item.created_at,
+      updatedAt: item.updated_at,
+    };
+  },
+});

package/dist/integrations/monday/files/ai/tools/list-boards.ts

@@ -0,0 +1,29 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listBoards } from "../../lib/monday-client.ts";
+
+export default tool({
+  id: "list-boards",
+  description: "List all boards in Monday.com. Can optionally filter by workspace IDs.",
+  inputSchema: z.object({
+    workspaceIds: z.array(z.string()).optional().describe("Optional list of workspace IDs to filter boards"),
+    limit: z.number().min(1).max(100).default(50).describe("Maximum number of boards to return"),
+    page: z.number().min(1).default(1).describe("Page number for pagination"),
+  }),
+  async execute({ workspaceIds, limit, page }) {
+    const boards = await listBoards({
+      workspaceIds,
+      limit,
+      page,
+    });
+
+    return boards.map((board) => ({
+      id: board.id,
+      name: board.name,
+      description: board.description,
+      boardKind: board.board_kind,
+      state: board.state,
+      workspaceId: board.workspace_id,
+    }));
+  },
+});

package/dist/integrations/monday/files/ai/tools/list-items.ts

@@ -0,0 +1,36 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listItems } from "../../lib/monday-client.ts";
+
+export default tool({
+  id: "list-items",
+  description: "List items from a Monday.com board. Items are the rows in a board.",
+  inputSchema: z.object({
+    boardId: z.string().describe("The ID of the board to list items from"),
+    limit: z.number().min(1).max(100).default(50).describe("Maximum number of items to return"),
+    page: z.number().min(1).default(1).describe("Page number for pagination"),
+  }),
+  async execute({ boardId, limit, page }) {
+    const items = await listItems({
+      boardId,
+      limit,
+      page,
+    });
+
+    return items.map((item) => ({
+      id: item.id,
+      name: item.name,
+      state: item.state,
+      board: item.board,
+      group: item.group,
+      columnValues: item.column_values?.map((col) => ({
+        id: col.id,
+        title: col.title,
+        text: col.text,
+        type: col.type,
+      })),
+      createdAt: item.created_at,
+      updatedAt: item.updated_at,
+    }));
+  },
+});

package/dist/integrations/monday/files/ai/tools/update-item.ts

@@ -0,0 +1,36 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { updateItem } from "../../lib/monday-client.ts";
+
+export default tool({
+  id: "update-item",
+  description: "Update an existing Monday.com item. Can update the name and/or column values.",
+  inputSchema: z.object({
+    itemId: z.string().describe("The ID of the item to update"),
+    name: z.string().optional().describe("New name/title for the item"),
+    columnValues: z.record(z.unknown()).optional().describe(
+      "Column values to update as a key-value object. Keys are column IDs, values depend on column type.",
+    ),
+  }),
+  async execute({ itemId, name, columnValues }) {
+    const item = await updateItem(itemId, {
+      name,
+      columnValues,
+    });
+
+    return {
+      success: true,
+      item: {
+        id: item.id,
+        name: item.name,
+        state: item.state,
+        columnValues: item.column_values?.map((col) => ({
+          id: col.id,
+          title: col.title,
+          text: col.text,
+          type: col.type,
+        })),
+      },
+    };
+  },
+});

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

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

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

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

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

@@ -0,0 +1,329 @@
+import { getAccessToken } from "./token-store.ts";
+
+const MONDAY_API_URL = "https://api.monday.com/v2";
+
+interface MondayResponse<T> {
+  data: T;
+  account_id?: number;
+  errors?: Array<{ message: string; locations?: unknown[] }>;
+}
+
+interface MondayBoard {
+  id: string;
+  name: string;
+  description?: string;
+  board_kind: string;
+  state: string;
+  workspace_id?: string;
+  created_at?: string;
+  updated_at?: string;
+}
+
+interface MondayItem {
+  id: string;
+  name: string;
+  state?: string;
+  board?: {
+    id: string;
+    name: string;
+  };
+  group?: {
+    id: string;
+    title: string;
+  };
+  column_values?: Array<{
+    id: string;
+    text?: string;
+    title?: string;
+    type?: string;
+    value?: string;
+  }>;
+  created_at?: string;
+  updated_at?: string;
+}
+
+interface MondayUser {
+  id: string;
+  name: string;
+  email: string;
+  account: {
+    id: string;
+    name: string;
+  };
+}
+
+async function mondayFetch<T>(query: string, variables?: Record<string, unknown>): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Monday.com. Please connect your account.");
+  }
+
+  const response = await fetch(MONDAY_API_URL, {
+    method: "POST",
+    headers: {
+      "Authorization": token,
+      "Content-Type": "application/json",
+      "API-Version": "2024-10",
+    },
+    body: JSON.stringify({
+      query,
+      variables: variables || {},
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Monday.com API error: ${response.status} ${response.statusText}`);
+  }
+
+  const result: MondayResponse<T> = await response.json();
+
+  if (result.errors && result.errors.length > 0) {
+    throw new Error(`Monday.com GraphQL error: ${result.errors[0].message}`);
+  }
+
+  return result.data;
+}
+
+export async function getMe(): Promise<MondayUser> {
+  const query = `
+    query {
+      me {
+        id
+        name
+        email
+        account {
+          id
+          name
+        }
+      }
+    }
+  `;
+
+  const data = await mondayFetch<{ me: MondayUser }>(query);
+  return data.me;
+}
+
+export async function listBoards(options?: {
+  limit?: number;
+  page?: number;
+  workspaceIds?: string[];
+}): Promise<MondayBoard[]> {
+  const limit = options?.limit || 50;
+  const page = options?.page || 1;
+
+  let workspaceFilter = "";
+  if (options?.workspaceIds && options.workspaceIds.length > 0) {
+    const ids = options.workspaceIds.map((id) => parseInt(id, 10));
+    workspaceFilter = `, workspace_ids: [${ids.join(",")}]`;
+  }
+
+  const query = `
+    query {
+      boards(limit: ${limit}, page: ${page}${workspaceFilter}) {
+        id
+        name
+        description
+        board_kind
+        state
+        workspace_id
+      }
+    }
+  `;
+
+  const data = await mondayFetch<{ boards: MondayBoard[] }>(query);
+  return data.boards;
+}
+
+export async function getBoard(boardId: string): Promise<MondayBoard> {
+  const query = `
+    query {
+      boards(ids: [${boardId}]) {
+        id
+        name
+        description
+        board_kind
+        state
+        workspace_id
+      }
+    }
+  `;
+
+  const data = await mondayFetch<{ boards: MondayBoard[] }>(query);
+  if (!data.boards || data.boards.length === 0) {
+    throw new Error(`Board with ID ${boardId} not found`);
+  }
+  return data.boards[0];
+}
+
+export async function listItems(options: {
+  boardId: string;
+  limit?: number;
+  page?: number;
+}): Promise<MondayItem[]> {
+  const limit = options.limit || 50;
+  const page = options.page || 1;
+
+  const query = `
+    query {
+      boards(ids: [${options.boardId}]) {
+        items_page(limit: ${limit}, query_params: {page: ${page}}) {
+          items {
+            id
+            name
+            state
+            board {
+              id
+              name
+            }
+            group {
+              id
+              title
+            }
+            column_values {
+              id
+              text
+              title
+              type
+              value
+            }
+            created_at
+            updated_at
+          }
+        }
+      }
+    }
+  `;
+
+  const data = await mondayFetch<{ boards: Array<{ items_page: { items: MondayItem[] } }> }>(query);
+  if (!data.boards || data.boards.length === 0) {
+    return [];
+  }
+  return data.boards[0].items_page.items;
+}
+
+export async function getItem(itemId: string): Promise<MondayItem> {
+  const query = `
+    query {
+      items(ids: [${itemId}]) {
+        id
+        name
+        state
+        board {
+          id
+          name
+        }
+        group {
+          id
+          title
+        }
+        column_values {
+          id
+          text
+          title
+          type
+          value
+        }
+        created_at
+        updated_at
+      }
+    }
+  `;
+
+  const data = await mondayFetch<{ items: MondayItem[] }>(query);
+  if (!data.items || data.items.length === 0) {
+    throw new Error(`Item with ID ${itemId} not found`);
+  }
+  return data.items[0];
+}
+
+export async function createItem(options: {
+  boardId: string;
+  groupId?: string;
+  itemName: string;
+  columnValues?: Record<string, unknown>;
+}): Promise<MondayItem> {
+  const groupId = options.groupId ? `group_id: "${options.groupId}",` : "";
+  const columnValues = options.columnValues
+    ? `column_values: ${JSON.stringify(JSON.stringify(options.columnValues))},`
+    : "";
+
+  const query = `
+    mutation {
+      create_item(
+        board_id: ${options.boardId},
+        ${groupId}
+        item_name: "${options.itemName}",
+        ${columnValues}
+      ) {
+        id
+        name
+        state
+        board {
+          id
+          name
+        }
+        group {
+          id
+          title
+        }
+        created_at
+      }
+    }
+  `;
+
+  const data = await mondayFetch<{ create_item: MondayItem }>(query);
+  return data.create_item;
+}
+
+export async function updateItem(
+  itemId: string,
+  updates: {
+    columnValues?: Record<string, unknown>;
+    name?: string;
+  },
+): Promise<MondayItem> {
+  let mutation = "";
+
+  if (updates.name) {
+    const nameQuery = `
+      mutation {
+        change_simple_column_value(
+          item_id: ${itemId},
+          column_id: "name",
+          value: "${updates.name}"
+        ) {
+          id
+          name
+        }
+      }
+    `;
+    await mondayFetch<{ change_simple_column_value: MondayItem }>(nameQuery);
+  }
+
+  if (updates.columnValues) {
+    const columnValuesStr = JSON.stringify(JSON.stringify(updates.columnValues));
+    mutation = `
+      mutation {
+        change_multiple_column_values(
+          item_id: ${itemId},
+          column_values: ${columnValuesStr}
+        ) {
+          id
+          name
+          state
+          column_values {
+            id
+            text
+            title
+            type
+            value
+          }
+        }
+      }
+    `;
+    const data = await mondayFetch<{ change_multiple_column_values: MondayItem }>(mutation);
+    return data.change_multiple_column_values;
+  }
+
+  return await getItem(itemId);
+}

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

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