veryfront 0.0.49 → 0.0.51

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/neon/connector.json

@@ -0,0 +1,89 @@
+{
+  "name": "neon",
+  "displayName": "Neon",
+  "icon": "neon.svg",
+  "description": "Manage Neon Postgres projects, branches, and execute database queries",
+  "auth": {
+    "type": "api-key",
+    "tokenName": "API Key",
+    "docsUrl": "https://neon.tech/docs/manage/api-keys",
+    "requiredApis": [
+      {
+        "name": "Neon Management API",
+        "enableUrl": "https://console.neon.tech/app/settings/api-keys"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "NEON_API_KEY",
+      "description": "Neon API Key for Management API access",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://neon.tech/docs/manage/api-keys"
+    },
+    {
+      "name": "DATABASE_URL",
+      "description": "PostgreSQL connection string for database queries",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://neon.tech/docs/connect/connect-from-any-app"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-projects",
+      "name": "List Projects",
+      "description": "List all Neon projects in your account",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-branches",
+      "name": "List Branches",
+      "description": "List all branches for a specific project",
+      "requiresWrite": false
+    },
+    {
+      "id": "query-database",
+      "name": "Query Database",
+      "description": "Execute SQL queries against the connected database",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-tables",
+      "name": "List Tables",
+      "description": "List all tables in the connected database",
+      "requiresWrite": false
+    },
+    {
+      "id": "describe-table",
+      "name": "Describe Table",
+      "description": "Get detailed schema information for a specific table",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "check-db-status",
+      "title": "Check database status",
+      "prompt": "Show me the status of my Neon projects and their branches.",
+      "category": "database",
+      "icon": "database"
+    },
+    {
+      "id": "explore-schema",
+      "title": "Explore database schema",
+      "prompt": "List all tables in my database and show me the schema for the main tables.",
+      "category": "database",
+      "icon": "table"
+    },
+    {
+      "id": "query-data",
+      "title": "Query database",
+      "prompt": "Help me query my database to find specific data.",
+      "category": "database",
+      "icon": "search"
+    }
+  ],
+  "suggestedWith": ["stripe", "clerk", "vercel"]
+}

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

@@ -0,0 +1,6 @@
+# Neon Integration
+# Create an API key at https://console.neon.tech/app/settings/api-keys
+# Get your connection string from your Neon project dashboard
+
+NEON_API_KEY=your_api_key_here
+DATABASE_URL=postgres://user:password@ep-xxxx.region.neon.tech/dbname?sslmode=require

package/dist/integrations/neon/files/ai/tools/describe-table.ts

@@ -0,0 +1,38 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { describeTable, getTableRowCount } from "../../lib/neon-client.ts";
+
+export default tool({
+  id: "describe-table",
+  description:
+    "Get detailed schema information for a specific table including column names, data types, nullability, defaults, and constraints.",
+  inputSchema: z.object({
+    tableName: z.string().describe("Name of the table to describe"),
+    schema: z.string().default("public").describe("Schema name where the table is located"),
+  }),
+  async execute({ tableName, schema }) {
+    const tableInfo = await describeTable(tableName, schema);
+
+    let rowCount: number | undefined;
+    try {
+      rowCount = await getTableRowCount(tableName, schema);
+    } catch (_error) {
+      // Row count is optional
+      rowCount = undefined;
+    }
+
+    return {
+      tableName: tableInfo.tableName,
+      schema: tableInfo.schema,
+      rowCount,
+      columnCount: tableInfo.columns.length,
+      columns: tableInfo.columns.map((col) => ({
+        name: col.column_name,
+        type: col.data_type,
+        nullable: col.is_nullable === "YES",
+        default: col.column_default,
+        maxLength: col.character_maximum_length,
+      })),
+    };
+  },
+});

package/dist/integrations/neon/files/ai/tools/list-branches.ts

@@ -0,0 +1,35 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listBranches } from "../../lib/neon-client.ts";
+
+export default tool({
+  id: "list-branches",
+  description:
+    "List all branches for a specific Neon project. Branches are isolated database environments that can be created from any point in time.",
+  inputSchema: z.object({
+    projectId: z.string().describe("The ID of the Neon project"),
+  }),
+  async execute({ projectId }) {
+    const branches = await listBranches(projectId);
+
+    return branches.map((branch) => ({
+      id: branch.id,
+      projectId: branch.project_id,
+      name: branch.name,
+      currentState: branch.current_state,
+      pendingState: branch.pending_state,
+      primary: branch.primary,
+      default: branch.default,
+      protected: branch.protected,
+      parentId: branch.parent_id,
+      parentLsn: branch.parent_lsn,
+      parentTimestamp: branch.parent_timestamp,
+      logicalSize: branch.logical_size,
+      createdAt: branch.created_at,
+      updatedAt: branch.updated_at,
+      cpuUsedSec: branch.cpu_used_sec,
+      computeTimeSec: branch.compute_time_sec,
+      activeTimeSec: branch.active_time_sec,
+    }));
+  },
+});

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

@@ -0,0 +1,31 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listProjects } from "../../lib/neon-client.ts";
+
+export default tool({
+  id: "list-projects",
+  description:
+    "List all Neon projects in your account. Returns project details including name, region, PostgreSQL version, and creation date.",
+  inputSchema: z.object({}),
+  async execute() {
+    const projects = await listProjects();
+
+    return projects.map((project) => ({
+      id: project.id,
+      name: project.name,
+      region: project.region_id,
+      pgVersion: project.pg_version,
+      proxyHost: project.proxy_host,
+      createdAt: project.created_at,
+      updatedAt: project.updated_at,
+      cpuUsedSec: project.cpu_used_sec,
+      autoscaling: project.default_endpoint_settings
+        ? {
+          minCu: project.default_endpoint_settings.autoscaling_limit_min_cu,
+          maxCu: project.default_endpoint_settings.autoscaling_limit_max_cu,
+          suspendTimeout: project.default_endpoint_settings.suspend_timeout_seconds,
+        }
+        : undefined,
+    }));
+  },
+});

package/dist/integrations/neon/files/ai/tools/list-tables.ts

@@ -0,0 +1,49 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getTableRowCount, listTables } from "../../lib/neon-client.ts";
+
+export default tool({
+  id: "list-tables",
+  description:
+    "List all tables in the connected database. Returns table names, schemas, and row counts to help understand the database structure.",
+  inputSchema: z.object({
+    schema: z.string().default("public").describe("Schema name to list tables from"),
+    includeRowCounts: z.boolean().default(false).describe(
+      "Whether to include row counts for each table (slower but more informative)",
+    ),
+  }),
+  async execute({ schema, includeRowCounts }) {
+    const tables = await listTables(schema);
+
+    const results = [];
+    for (const table of tables) {
+      const result: {
+        tablename: string;
+        schemaname: string;
+        tableowner: string;
+        rowCount?: number;
+      } = {
+        tablename: table.tablename,
+        schemaname: table.schemaname,
+        tableowner: table.tableowner,
+      };
+
+      if (includeRowCounts) {
+        try {
+          result.rowCount = await getTableRowCount(table.tablename, schema);
+        } catch (_error) {
+          // Skip row count if there's an error
+          result.rowCount = undefined;
+        }
+      }
+
+      results.push(result);
+    }
+
+    return {
+      schema,
+      tableCount: results.length,
+      tables: results,
+    };
+  },
+});