veryfront 0.0.48 → 0.0.50

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,
+    };
+  },
+});

package/dist/integrations/neon/files/ai/tools/query-database.ts

@@ -0,0 +1,33 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { query } from "../../lib/neon-client.ts";
+
+export default tool({
+  id: "query-database",
+  description:
+    "Execute SQL queries against the connected Neon database. Supports parameterized queries for safety. Use this to retrieve, analyze, or search data.",
+  inputSchema: z.object({
+    sql: z.string().describe("SQL query to execute. Use $1, $2, etc. for parameters"),
+    params: z.array(z.union([z.string(), z.number(), z.boolean(), z.null()])).optional().describe(
+      "Optional array of parameter values for the query",
+    ),
+    limit: z.number().min(1).max(1000).default(100).describe("Maximum number of rows to return"),
+  }),
+  async execute({ sql, params, limit }) {
+    // Add LIMIT clause if not present and it's a SELECT query
+    let finalSql = sql.trim();
+    const isSelectQuery = /^SELECT/i.test(finalSql);
+
+    if (isSelectQuery && !/LIMIT\s+\d+/i.test(finalSql)) {
+      finalSql = `${finalSql} LIMIT ${limit}`;
+    }
+
+    const result = await query(finalSql, params);
+
+    return {
+      rows: result.rows,
+      rowCount: result.rowCount,
+      limited: isSelectQuery && result.rowCount >= limit,
+    };
+  },
+});

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

@@ -0,0 +1,51 @@
+import { setApiKey } from "../../../../lib/token-store";
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { apiKey, databaseUrl } = body;
+
+    if (!apiKey) {
+      return Response.json(
+        { error: "API key is required" },
+        { status: 400 },
+      );
+    }
+
+    // Validate the API key by making a test request to Neon API
+    const response = await fetch("https://console.neon.tech/api/v2/projects", {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Accept": "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      return Response.json(
+        { error: "Invalid API key" },
+        { status: 401 },
+      );
+    }
+
+    // Store the API key
+    setApiKey(apiKey, databaseUrl);
+
+    return Response.json({
+      success: true,
+      message: "Successfully authenticated with Neon",
+    });
+  } catch (error) {
+    console.error("Neon auth error:", error);
+    return Response.json(
+      { error: "Authentication failed" },
+      { status: 500 },
+    );
+  }
+}
+
+export function GET() {
+  return Response.json({
+    authenticated: false,
+    message: "Use POST to authenticate with API key",
+  });
+}

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

@@ -0,0 +1,294 @@
+import { getApiKey, getDatabaseUrl } from "./token-store.ts";
+import { Client } from "pg";
+
+const NEON_API_BASE_URL = "https://console.neon.tech/api/v2";
+
+// Management API Types
+interface NeonProject {
+  id: string;
+  platform_id: string;
+  region_id: string;
+  name: string;
+  provisioner: string;
+  default_endpoint_settings?: {
+    autoscaling_limit_min_cu: number;
+    autoscaling_limit_max_cu: number;
+    suspend_timeout_seconds: number;
+  };
+  settings?: {
+    quota?: {
+      active_time_seconds?: number;
+      compute_time_seconds?: number;
+      written_data_bytes?: number;
+      data_transfer_bytes?: number;
+    };
+  };
+  pg_version: number;
+  store_passwords: boolean;
+  creation_source: string;
+  created_at: string;
+  updated_at: string;
+  proxy_host: string;
+  branch_logical_size_limit: number;
+  branch_logical_size_limit_bytes: number;
+  cpu_used_sec: number;
+  maintenance_starts_at?: string;
+}
+
+interface NeonBranch {
+  id: string;
+  project_id: string;
+  parent_id?: string;
+  parent_lsn?: string;
+  parent_timestamp?: string;
+  name: string;
+  current_state: string;
+  pending_state?: string;
+  logical_size?: number;
+  creation_source: string;
+  primary?: boolean;
+  default?: boolean;
+  protected?: boolean;
+  cpu_used_sec: number;
+  compute_time_sec?: number;
+  active_time_sec?: number;
+  written_data_bytes?: number;
+  data_transfer_bytes?: number;
+  created_at: string;
+  updated_at: string;
+}
+
+interface NeonProjectsResponse {
+  projects: NeonProject[];
+}
+
+interface NeonBranchesResponse {
+  branches: NeonBranch[];
+}
+
+interface NeonEndpoint {
+  host: string;
+  id: string;
+  project_id: string;
+  branch_id: string;
+  autoscaling_limit_min_cu: number;
+  autoscaling_limit_max_cu: number;
+  region_id: string;
+  type: string;
+  current_state: string;
+  settings: {
+    pg_settings?: Record<string, string>;
+  };
+  pooler_enabled: boolean;
+  pooler_mode?: string;
+  disabled: boolean;
+  passwordless_access: boolean;
+  creation_source: string;
+  created_at: string;
+  updated_at: string;
+  proxy_host: string;
+  suspend_timeout_seconds: number;
+  provisioner: string;
+}
+
+interface NeonEndpointsResponse {
+  endpoints: NeonEndpoint[];
+}
+
+// Database Query Types
+interface QueryResult {
+  rows: Record<string, unknown>[];
+  rowCount: number;
+  fields: Array<{ name: string; dataTypeID: number }>;
+}
+
+interface TableInfo {
+  tablename: string;
+  schemaname: string;
+  tableowner: string;
+}
+
+interface ColumnInfo {
+  column_name: string;
+  data_type: string;
+  is_nullable: string;
+  column_default: string | null;
+  character_maximum_length: number | null;
+}
+
+async function neonFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const apiKey = getApiKey() || process.env.NEON_API_KEY;
+  if (!apiKey) {
+    throw new Error("Not authenticated with Neon. Please set NEON_API_KEY.");
+  }
+
+  const response = await fetch(`${NEON_API_BASE_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Neon API error: ${response.status} ${error.message || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+// Management API Functions
+
+export async function listProjects(): Promise<NeonProject[]> {
+  const response = await neonFetch<NeonProjectsResponse>("/projects");
+  return response.projects;
+}
+
+export function getProject(projectId: string): Promise<NeonProject> {
+  return neonFetch<NeonProject>(`/projects/${projectId}`);
+}
+
+export async function listBranches(projectId: string): Promise<NeonBranch[]> {
+  const response = await neonFetch<NeonBranchesResponse>(
+    `/projects/${projectId}/branches`,
+  );
+  return response.branches;
+}
+
+export async function createBranch(
+  projectId: string,
+  options: {
+    name?: string;
+    parentId?: string;
+    parentLsn?: string;
+    parentTimestamp?: string;
+  },
+): Promise<NeonBranch> {
+  const body: Record<string, unknown> = {
+    branch: {
+      name: options.name,
+    },
+  };
+
+  if (options.parentId) {
+    body.branch = { ...body.branch, parent_id: options.parentId };
+  }
+  if (options.parentLsn) {
+    body.branch = { ...body.branch, parent_lsn: options.parentLsn };
+  }
+  if (options.parentTimestamp) {
+    body.branch = { ...body.branch, parent_timestamp: options.parentTimestamp };
+  }
+
+  const response = await neonFetch<{ branch: NeonBranch }>(
+    `/projects/${projectId}/branches`,
+    {
+      method: "POST",
+      body: JSON.stringify(body),
+    },
+  );
+
+  return response.branch;
+}
+
+export async function listEndpoints(projectId: string): Promise<NeonEndpoint[]> {
+  const response = await neonFetch<NeonEndpointsResponse>(
+    `/projects/${projectId}/endpoints`,
+  );
+  return response.endpoints;
+}
+
+// Database Query Functions
+
+async function getDbClient(): Promise<Client> {
+  const databaseUrl = getDatabaseUrl();
+  if (!databaseUrl) {
+    throw new Error("DATABASE_URL not configured. Please set DATABASE_URL environment variable.");
+  }
+
+  const client = new Client({
+    connectionString: databaseUrl,
+    ssl: {
+      rejectUnauthorized: false,
+    },
+  });
+
+  await client.connect();
+  return client;
+}
+
+export async function query<T = Record<string, unknown>>(
+  sql: string,
+  params?: unknown[],
+): Promise<{ rows: T[]; rowCount: number }> {
+  const client = await getDbClient();
+
+  try {
+    const result = await client.query(sql, params);
+    return {
+      rows: result.rows as T[],
+      rowCount: result.rowCount || 0,
+    };
+  } finally {
+    await client.end();
+  }
+}
+
+export async function listTables(schema: string = "public"): Promise<TableInfo[]> {
+  const result = await query<TableInfo>(
+    `SELECT tablename, schemaname, tableowner
+     FROM pg_tables
+     WHERE schemaname = $1
+     ORDER BY tablename`,
+    [schema],
+  );
+
+  return result.rows;
+}
+
+export async function describeTable(
+  tableName: string,
+  schema: string = "public",
+): Promise<{
+  tableName: string;
+  schema: string;
+  columns: ColumnInfo[];
+}> {
+  const result = await query<ColumnInfo>(
+    `SELECT
+      column_name,
+      data_type,
+      is_nullable,
+      column_default,
+      character_maximum_length
+    FROM information_schema.columns
+    WHERE table_schema = $1 AND table_name = $2
+    ORDER BY ordinal_position`,
+    [schema, tableName],
+  );
+
+  return {
+    tableName,
+    schema,
+    columns: result.rows,
+  };
+}
+
+export async function getTableRowCount(
+  tableName: string,
+  schema: string = "public",
+): Promise<number> {
+  const result = await query<{ count: string }>(
+    `SELECT COUNT(*) as count FROM "${schema}"."${tableName}"`,
+  );
+
+  return parseInt(result.rows[0]?.count || "0", 10);
+}

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

@@ -0,0 +1,29 @@
+// In-memory token store for development
+// For production, replace with a database-backed implementation
+
+interface TokenData {
+  apiKey: string;
+  databaseUrl?: string;
+}
+
+let tokenStore: TokenData | null = null;
+
+export function setApiKey(apiKey: string, databaseUrl?: string): void {
+  tokenStore = { apiKey, databaseUrl };
+}
+
+export function getApiKey(): string | null {
+  return tokenStore?.apiKey || null;
+}
+
+export function getDatabaseUrl(): string | null {
+  return tokenStore?.databaseUrl || process.env.DATABASE_URL || null;
+}
+
+export function clearTokens(): void {
+  tokenStore = null;
+}
+
+export function isAuthenticated(): boolean {
+  return tokenStore !== null && tokenStore.apiKey !== null;
+}